Merge pull request #279 from jamashita/release

chore(deps): bump ip from 2.0.0 to 2.0.1

CHANGELOG.md

@@ -1,3 +1,18 @@
+# [1.22.0](https://github.com/jamashita/lluvia/compare/v1.21.0...v1.22.0) (2024-04-23)
+
+
+### Features
+
+* 🎸 packages updated ([f9cf656](https://github.com/jamashita/lluvia/commit/f9cf6569bd7ffab92c173f3985b67b5357dcba19))
+
+# [1.21.0](https://github.com/jamashita/lluvia/compare/v1.20.0...v1.21.0) (2024-04-23)
+
+
+### Features
+
+* 🎸 chunk(), shuffle() ([84c7bf5](https://github.com/jamashita/lluvia/commit/84c7bf59e78f8c07b0905d1b682c84376414bcf9))
+* 🎸 errors ([039a6b6](https://github.com/jamashita/lluvia/commit/039a6b69e4ae4ce1e2f2eeaa9fbf6cb29c249274))
+
 # [1.20.0](https://github.com/jamashita/lluvia/compare/v1.19.0...v1.20.0) (2024-04-17)
 
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jamashita/lluvia",
-  "version": "1.20.0",
+  "version": "1.22.0",
   "private": false,
   "repository": {
     "type": "git",
@@ -70,29 +70,30 @@
     "update:upgrade": "ncu --packageManager yarn --deep --upgrade"
   },
   "dependencies": {
-    "@jamashita/anden": "2.7.0"
+    "@jamashita/anden": "2.8.0",
+    "@jamashita/steckdose": "1.32.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "1.6.4",
-    "@commitlint/cli": "18.4.4",
-    "@commitlint/config-conventional": "18.4.4",
+    "@biomejs/biome": "1.7.1",
+    "@commitlint/cli": "19.2.2",
+    "@commitlint/config-conventional": "19.2.2",
     "@semantic-release/changelog": "6.0.3",
-    "@semantic-release/commit-analyzer": "11.1.0",
+    "@semantic-release/commit-analyzer": "12.0.0",
     "@semantic-release/git": "10.0.1",
-    "@semantic-release/github": "9.2.6",
-    "@semantic-release/npm": "11.0.2",
-    "@semantic-release/release-notes-generator": "12.1.0",
-    "@types/node": "20.11.4",
+    "@semantic-release/github": "10.0.3",
+    "@semantic-release/npm": "12.0.0",
+    "@semantic-release/release-notes-generator": "13.0.0",
+    "@types/node": "20.12.7",
     "git-cz": "4.9.0",
-    "husky": "8.0.3",
+    "husky": "9.0.11",
     "is-ci": "3.0.1",
-    "lint-staged": "15.2.0",
-    "npm-check-updates": "16.14.12",
+    "lint-staged": "15.2.2",
+    "npm-check-updates": "16.14.18",
     "rimraf": "5.0.5",
-    "semantic-release": "22.0.12",
-    "sort-package-json": "2.6.0",
-    "typescript": "5.3.3",
-    "vitest": "1.2.0"
+    "semantic-release": "23.0.8",
+    "sort-package-json": "2.10.0",
+    "typescript": "5.4.5",
+    "vitest": "1.5.0"
   },
   "engines": {
     "node": ">=18.x"

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
+}