Merge pull request #276 from jamashita/develop

chore(deps): bump ip from 2.0.0 to 2.0.1

package.json

@@ -70,7 +70,8 @@
     "update:upgrade": "ncu --packageManager yarn --deep --upgrade"
   },
   "dependencies": {
-    "@jamashita/anden": "2.7.0"
+    "@jamashita/anden": "2.7.0",
+    "@jamashita/steckdose": "1.32.0"
   },
   "devDependencies": {
     "@biomejs/biome": "1.6.4",

src/address/AddressError.ts

@@ -0,0 +1,5 @@
+import { CollectionError } from '../collection/index.js';
+
+export class AddressError extends CollectionError {
+  // NOOP
+}

src/address/index.ts

@@ -1,5 +1,6 @@
 export * from './mock/index.js';
 export * from './Address.js';
+export * from './AddressError.js';
 export * from './ImmutableAddress.js';
 export * from './MutableAddress.js';
 export * from './ReadonlyAddress.js';

src/collection/CollectionError.ts

@@ -0,0 +1,5 @@
+import { RuntimeError } from '@jamashita/anden/error';
+
+export class CollectionError extends RuntimeError {
+  // NOOP
+}

src/collection/index.ts

@@ -1,2 +1,3 @@
 export * from './Collection.js';
+export * from './CollectionError.js';
 export * from './Quantity.js';

src/dictionary/DictionaryError.ts

@@ -0,0 +1,5 @@
+import { CollectionError } from '../collection/index.js';
+
+export class DictionaryError extends CollectionError {
+  // NOOP
+}

src/dictionary/index.ts

@@ -1,5 +1,6 @@
 export * from './mock/index.js';
+export * from './Dictionary.js';
+export * from './DictionaryError.js';
 export * from './ImmutableDictionary.js';
 export * from './MutableDictionary.js';
-export * from './Dictionary.js';
 export * from './ReadonlyDictionary.js';

src/sequence/ASequence.ts

@@ -9,8 +9,10 @@ import {
   type Nullable,
   type Undefinable
 } from '@jamashita/anden/type';
+import { Random } from '@jamashita/steckdose/random';
 import { type NarrowingBinaryPredicate, Quantity } from '../collection/index.js';
 import type { Sequence } from './Sequence.js';
+import { SequenceError } from './SequenceError.js';
 
 export abstract class ASequence<out V> extends Quantity<number, V> implements Sequence<V> {
   protected sequence: Array<V>;
@@ -22,19 +24,49 @@ export abstract class ASequence<out V> extends Quantity<number, V> implements Se
 
   public abstract add(value: V): ASequence<V>;
 
+  public abstract chunk(size: number): ASequence<ASequence<V>>;
+
   public abstract duplicate(): ASequence<V>;
 
-  public abstract override filter<W extends V>(predicate: NarrowingBinaryPredicate<V, W, number>): ASequence<W>;
   public abstract override filter(predicate: BinaryPredicate<V, number>): ASequence<V>;
 
+  public abstract override filter<W extends V>(predicate: NarrowingBinaryPredicate<V, W, number>): ASequence<W>;
+
   public abstract override map<W>(mapping: Mapping<V, W>): ASequence<W>;
 
   public abstract remove(key: number): ASequence<V>;
 
   public abstract set(key: number, value: V): ASequence<V>;
 
+  public abstract shuffle(): ASequence<V>;
+
   public abstract sort(comparator: BinaryFunction<V, V, number>): ASequence<V>;
 
+  protected chunkInternal(size: number): Array<Array<V>> {
+    if (size <= 0) {
+      throw new SequenceError(`CHUNK SIZE MUST BE GREATER THAN 0. GIVEN: ${size}`);
+    }
+    if (!Kind.isInteger(size)) {
+      throw new SequenceError(`CHUNK SIZE MUST BE INTEGER. GIVEN: ${size}`);
+    }
+
+    const arr: Array<Array<V>> = [];
+    let chunk: Array<V> = [];
+
+    this.sequence.forEach((v: V, i: number) => {
+      if (i % size === 0 && i !== 0) {
+        arr.push(chunk);
+        chunk = [];
+      }
+
+      chunk.push(v);
+    });
+
+    arr.push(chunk);
+
+    return arr;
+  }
+
   public contains(value: V): boolean {
     const found: Undefinable<V> = this.sequence.find((v: V) => {
       if (v === value) {
@@ -135,10 +167,10 @@ export abstract class ASequence<out V> extends Quantity<number, V> implements Se
 
   protected removeInternal(key: number): Array<V> {
     if (!Kind.isInteger(key)) {
-      return this.sequence;
+      throw new SequenceError(`REMOVE KEY MUST BE INTEGER. GIVEN: ${key}`);
     }
     if (key < 0 || this.sequence.length <= key) {
-      return this.sequence;
+      throw new SequenceError(`REMOVE KEY IS OUT OF BOUND. GIVEN: ${key}`);
     }
 
     return [...this.sequence.slice(0, key), ...this.sequence.slice(key + 1)];
@@ -154,15 +186,27 @@ export abstract class ASequence<out V> extends Quantity<number, V> implements Se
 
   protected setInternal(key: number, value: V): Array<V> {
     if (!Kind.isInteger(key)) {
-      return this.sequence;
+      throw new SequenceError(`SET KEY MUST BE INTEGER. GIVEN: ${key}`);
     }
     if (key < 0 || this.sequence.length <= key) {
-      return this.sequence;
+      throw new SequenceError(`SET KEY IS OUT OF BOUND. GIVEN: ${key}`);
     }
 
     return [...this.sequence.slice(0, key), value, ...this.sequence.slice(key + 1)];
   }
 
+  protected shuffleInternal(): Array<V> {
+    const arr: Array<V> = [...this.sequence];
+
+    for (let i: number = arr.length - 1; i >= 0; i--) {
+      const j: number = Random.integer(0, i);
+      // biome-ignore lint/style/noNonNullAssertion: <explanation>
+      [arr[i], arr[j]] = [arr[j]!, arr[i]!];
+    }
+
+    return arr;
+  }
+
   public size(): number {
     return this.sequence.length;
   }

src/sequence/ImmutableSequence.ts

@@ -41,6 +41,14 @@ export class ImmutableSequence<out V> extends ASequence<V> {
     return ImmutableSequence.ofArray([...this.sequence, value]);
   }
 
+  public chunk(size: number): ImmutableSequence<ImmutableSequence<V>> {
+    const sequences: Array<ImmutableSequence<V>> = this.chunkInternal(size).map((arr: Array<V>) => {
+      return ImmutableSequence.ofArray(arr);
+    });
+
+    return ImmutableSequence.ofArray(sequences);
+  }
+
   public duplicate(): ImmutableSequence<V> {
     if (this.isEmpty()) {
       return ImmutableSequence.empty();
@@ -50,7 +58,9 @@ export class ImmutableSequence<out V> extends ASequence<V> {
   }
 
   public filter<W extends V>(predicate: NarrowingBinaryPredicate<V, W, number>): ImmutableSequence<W>;
+
   public filter(predicate: BinaryPredicate<V, number>): ImmutableSequence<V>;
+
   public filter<W extends V = V>(predicate: NarrowingBinaryPredicate<V, W, number>): ImmutableSequence<W> {
     return ImmutableSequence.ofArray(this.filterInternal(predicate));
   }
@@ -87,6 +97,10 @@ export class ImmutableSequence<out V> extends ASequence<V> {
     return ImmutableSequence.ofArray(sequence);
   }
 
+  public shuffle(): ImmutableSequence<V> {
+    return ImmutableSequence.ofArray(this.shuffleInternal());
+  }
+
   public sort(comparator: BinaryFunction<V, V, number>): ImmutableSequence<V> {
     const arr: Array<V> = this.toArray();
 

src/sequence/MutableSequence.ts

@@ -37,12 +37,22 @@ export class MutableSequence<out V> extends ASequence<V> {
     return this;
   }
 
+  public chunk(size: number): ASequence<ASequence<V>> {
+    const sequences: Array<MutableSequence<V>> = this.chunkInternal(size).map((arr: Array<V>) => {
+      return MutableSequence.ofArray(arr);
+    });
+
+    return MutableSequence.ofArray(sequences);
+  }
+
   public duplicate(): MutableSequence<V> {
     return MutableSequence.ofArray([...this.sequence]);
   }
 
   public filter<W extends V>(predicate: NarrowingBinaryPredicate<V, W, number>): MutableSequence<W>;
+
   public filter(predicate: BinaryPredicate<V, number>): MutableSequence<V>;
+
   public filter<W extends V = V>(predicate: NarrowingBinaryPredicate<V, W, number>): MutableSequence<W> {
     return MutableSequence.ofArray(this.filterInternal(predicate));
   }
@@ -63,6 +73,10 @@ export class MutableSequence<out V> extends ASequence<V> {
     return this;
   }
 
+  public shuffle(): ASequence<V> {
+    return MutableSequence.ofArray(this.shuffleInternal());
+  }
+
   public sort(comparator: BinaryFunction<V, V, number>): MutableSequence<V> {
     const arr: Array<V> = [...this.sequence];
 

src/sequence/ReadonlySequence.ts

@@ -2,14 +2,18 @@ import type { BinaryFunction, BinaryPredicate, Cloneable, Mapping } from '@jamas
 import type { Collection, NarrowingBinaryPredicate } from '../collection/index.js';
 
 export interface ReadonlySequence<out V> extends Collection<number, V>, Cloneable<ReadonlySequence<V>> {
-  filter<W extends V>(predicate: NarrowingBinaryPredicate<V, W, number>): ReadonlySequence<W>;
+  chunk(size: number): ReadonlySequence<ReadonlySequence<V>>;
 
   filter(predicate: BinaryPredicate<V, number>): ReadonlySequence<V>;
 
+  filter<W extends V>(predicate: NarrowingBinaryPredicate<V, W, number>): ReadonlySequence<W>;
+
   map<W>(mapping: Mapping<V, W>): ReadonlySequence<W>;
 
   reduce(reducer: BinaryFunction<V, V, V>, initialValue?: V): V;
 
+  shuffle(): ReadonlySequence<V>;
+
   sort(comparator: BinaryFunction<V, V, number>): ReadonlySequence<V>;
 
   toArray(): Array<V>;

src/sequence/SequenceError.ts

@@ -0,0 +1,5 @@
+import { CollectionError } from '../collection/CollectionError.js';
+
+export class SequenceError extends CollectionError {
+  // NOOP
+}

src/sequence/__tests__/ImmutableSequence.spec.ts

@@ -1,6 +1,7 @@
 import { MockValueObject } from '@jamashita/anden/object';
 import type { Nullable } from '@jamashita/anden/type';
 import { ImmutableSequence } from '../ImmutableSequence.js';
+import { SequenceError } from '../SequenceError.js';
 
 describe('ImmutableSequence', () => {
   describe('await', () => {
@@ -250,37 +251,40 @@ describe('ImmutableSequence', () => {
       expect(sequence2.get(1)).toBe(value2);
     });
 
-    it('returns itself when given key is greater than sequence length', () => {
+    it('throws SequenceError when given key is greater than sequence length', () => {
       const value1: MockValueObject<number> = new MockValueObject(1);
       const value2: MockValueObject<number> = new MockValueObject(2);
       const value3: MockValueObject<number> = new MockValueObject(3);
 
       const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([value1, value2, value3]);
-      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.remove(3);
 
-      expect(sequence1).toBe(sequence2);
+      expect(() => {
+        sequence1.remove(3);
+      }).toThrow(SequenceError);
     });
 
-    it('returns itself when given key is less than 0', () => {
+    it('throws SequenceError when given key is less than 0', () => {
       const value1: MockValueObject<number> = new MockValueObject(1);
       const value2: MockValueObject<number> = new MockValueObject(2);
       const value3: MockValueObject<number> = new MockValueObject(3);
 
       const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([value1, value2, value3]);
-      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.remove(-1);
 
-      expect(sequence1).toBe(sequence2);
+      expect(() => {
+        sequence1.remove(-1);
+      }).toThrow(SequenceError);
     });
 
-    it('returns itself when given key is not integer', () => {
+    it('throws SequenceError when given key is not integer', () => {
       const value1: MockValueObject<number> = new MockValueObject(1);
       const value2: MockValueObject<number> = new MockValueObject(2);
       const value3: MockValueObject<number> = new MockValueObject(3);
 
       const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([value1, value2, value3]);
-      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.remove(0.8);
 
-      expect(sequence1).toBe(sequence2);
+      expect(() => {
+        sequence1.remove(0.8);
+      }).toThrow(SequenceError);
     });
   });
 
@@ -336,42 +340,43 @@ describe('ImmutableSequence', () => {
       expect(sequence2.get(2)).toBe(value4);
     });
 
-    it('returns itself when given key is less than 0', () => {
+    it('throws SequenceError when given key is less than 0', () => {
       const value1: MockValueObject<number> = new MockValueObject(1);
       const value2: MockValueObject<number> = new MockValueObject(2);
       const value3: MockValueObject<number> = new MockValueObject(3);
       const value4: MockValueObject<number> = new MockValueObject(4);
 
       const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([value1, value2, value3]);
-      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(-1, value4);
 
-      expect(sequence1).toBe(sequence2);
+      expect(() => {
+        sequence1.set(-1, value4);
+      }).toThrow(SequenceError);
     });
 
-    it('returns itself when given key is greater than sequence length', () => {
+    it('throws SequenceError when given key is greater than sequence length', () => {
       const value1: MockValueObject<number> = new MockValueObject(1);
       const value2: MockValueObject<number> = new MockValueObject(2);
       const value3: MockValueObject<number> = new MockValueObject(3);
       const value4: MockValueObject<number> = new MockValueObject(4);
 
       const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([value1, value2, value3]);
 
-      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(sequence1.size(), value4);
-
-      expect(sequence1).toBe(sequence2);
+      expect(() => {
+        sequence1.set(sequence1.size(), value4);
+      }).toThrow(SequenceError);
     });
 
-    it('returns itself when given key is not integer', () => {
+    it('throws SequenceError when given key is not integer', () => {
       const value1: MockValueObject<number> = new MockValueObject(1);
       const value2: MockValueObject<number> = new MockValueObject(2);
       const value3: MockValueObject<number> = new MockValueObject(3);
       const value4: MockValueObject<number> = new MockValueObject(4);
 
       const sequence1: ImmutableSequence<MockValueObject<number>> = ImmutableSequence.ofArray([value1, value2, value3]);
 
-      const sequence2: ImmutableSequence<MockValueObject<number>> = sequence1.set(2.2, value4);
-
-      expect(sequence1).toBe(sequence2);
+      expect(() => {
+        sequence1.set(2.2, value4);
+      }).toThrow(SequenceError);
     });
   });