chore(core/stdlib): fix lint

core/stdlib/src/patterns/behavioral/Command/types.ts

@@ -1,11 +1,11 @@
 import type { MaybePromise } from '../../../types';
 
-export type Command = {
+export interface Command {
   execute: () => void;
   undo: () => void;
-};
+}
 
-export type AsyncCommand = {
+export interface AsyncCommand {
   execute: () => MaybePromise<void>;
   undo: () => MaybePromise<void>;
-};
+}

core/stdlib/src/patterns/behavioral/StateMachine/base.ts

@@ -8,7 +8,7 @@
  */
 export class BaseStateMachine<
   States extends string,
-  Events extends string,
+  _Events extends string,
   Context,
   NodeConfig,
 > {

core/stdlib/src/patterns/behavioral/StateMachine/types.ts

@@ -7,18 +7,18 @@ import type { MaybePromise } from '../../../types';
  * @template Guard - Guard return type (boolean or MaybePromise\<boolean\>)
  * @template Action - Action return type (void or MaybePromise\<void\>)
  */
-export type TransitionConfig<
+export interface TransitionConfig<
   Context,
   Guard = boolean,
   Action = void,
-> = {
+> {
   /** Target state to transition to */
   target: string;
   /** Guard condition — transition only occurs if this returns true */
   guard?: (context: Context) => Guard;
   /** Side effect executed during transition (before entering target state) */
   action?: (context: Context) => Action;
-};
+}
 
 /**
  * A transition can be a target state name or a detailed configuration
@@ -36,18 +36,18 @@ export type Transition<
  * @template Guard - Guard return type
  * @template Hook - Hook return type (entry/exit/action)
  */
-export type StateNodeConfig<
+export interface StateNodeConfig<
   Context,
   Guard = boolean,
   Hook = void,
-> = {
+> {
   /** Map of event names to transitions */
   on?: Record<string, Transition<Context, Guard, Hook>>;
   /** Hook called when entering this state */
   entry?: (context: Context) => Hook;
   /** Hook called when exiting this state */
   exit?: (context: Context) => Hook;
-};
+}
 
 /** Sync state node config — guards return boolean, hooks return void */
 export type SyncStateNodeConfig<Context> = StateNodeConfig<Context, boolean, void>;

core/stdlib/src/structs/BinaryHeap/index.ts

@@ -52,7 +52,7 @@ export class BinaryHeap<T> implements BinaryHeapLike<T> {
     constructor(initialValues?: T[] | T, options?: BinaryHeapOptions<T>) {
         this.comparator = options?.comparator ?? defaultComparator;
 
-        if (initialValues != null) {
+        if (initialValues !== null && initialValues !== undefined) {
             const items = isArray(initialValues) ? initialValues : [initialValues];
             this.heap.push(...items);
             this.heapify();

core/stdlib/src/structs/CircularBuffer/index.ts

@@ -21,7 +21,7 @@ export class CircularBuffer<T> implements CircularBufferLike<T> {
    * @private
    * @type {(T | undefined)[]}
    */
-  private buffer: (T | undefined)[];
+  private buffer: Array<T | undefined>;
 
   /**
    * The index of the front element
@@ -53,7 +53,7 @@ export class CircularBuffer<T> implements CircularBufferLike<T> {
     const requested = Math.max(items.length, initialCapacity ?? 0);
     const cap = Math.max(MIN_CAPACITY, nextPowerOfTwo(requested));
 
-    this.buffer = new Array(cap);
+    this.buffer = Array.from<T | undefined>({ length: cap });
 
     for (const item of items)
       this.pushBack(item);
@@ -190,7 +190,7 @@ export class CircularBuffer<T> implements CircularBufferLike<T> {
    * @returns {this}
    */
   clear() {
-    this.buffer = new Array(MIN_CAPACITY);
+    this.buffer = Array.from<T | undefined>({ length: MIN_CAPACITY });
     this.head = 0;
     this.count = 0;
 
@@ -203,7 +203,7 @@ export class CircularBuffer<T> implements CircularBufferLike<T> {
    * @returns {T[]}
    */
   toArray() {
-    const result = new Array<T>(this.count);
+    const result = Array.from<T>({ length: this.count });
 
     for (let i = 0; i < this.count; i++)
       result[i] = this.buffer[(this.head + i) & (this.buffer.length - 1)] as T;
@@ -246,7 +246,7 @@ export class CircularBuffer<T> implements CircularBufferLike<T> {
    */
   private grow() {
     const newCapacity = this.buffer.length << 1;
-    const newBuffer = new Array<T | undefined>(newCapacity);
+    const newBuffer = Array.from<T | undefined>({ length: newCapacity });
 
     for (let i = 0; i < this.count; i++)
       newBuffer[i] = this.buffer[(this.head + i) & (this.buffer.length - 1)];

core/stdlib/src/structs/LinkedList/index.ts

@@ -30,7 +30,7 @@ export class LinkedList<T> implements LinkedListLike<T> {
      * @private
      * @type {number}
      */
-    private count: number = 0;
+    private count = 0;
 
     /**
      * The first node in the list
@@ -54,7 +54,7 @@ export class LinkedList<T> implements LinkedListLike<T> {
      * @param {(T[] | T)} [initialValues] The initial values to add to the list
      */
     constructor(initialValues?: T[] | T) {
-        if (initialValues != null) {
+        if (initialValues !== null && initialValues !== undefined) {
             const items = isArray(initialValues) ? initialValues : [initialValues];
 
             for (const item of items)
@@ -258,7 +258,7 @@ export class LinkedList<T> implements LinkedListLike<T> {
      * @returns {T[]} Array of values from head to tail
      */
     public toArray(): T[] {
-        const result = new Array<T>(this.count);
+        const result = Array.from<T>({ length: this.count });
         let current = this.first;
         let i = 0;