Merge pull request #270 from jamashita/develop

Merge pull request #264 from jamashita/release

.lintstagedrc.json

@@ -1,4 +1,4 @@
 {
-  "packages/**/src/**/*.{ts,tsx}": "eslint --fix --quiet",
+  "src/**/*.{ts,tsx}": "yarn format && yarn lint",
   "package.json": "sort-package-json"
 }

.mise.toml

@@ -1,2 +1,2 @@
 [tools]
-node = "20.10.0"
+node = "20.12.2"

.npmignore

@@ -1,19 +1,14 @@
-.husky/
 .github/
+.husky/
 .idea/
-coverage/
 .editorconfig
-.eslintignore
-.eslintrc
 .lintstagedrc.json
 .releaserc.json
-babel.config.cjs
+biome.json
 commitlint.config.cjs
-jest.config.cjs
-lerna.json
+tsconfig.compilation.json
 tsconfig.json
-tsconfig.build.json
-tsconfig.build.tsbuildinfo
+vitest.config.ts
 **/*.spec.ts
 *.log
 *.md

.yarnrc.yml

@@ -0,0 +1 @@
+nodeLinker: node-modules

README.md

@@ -17,10 +17,10 @@ yarn add @jamashita/lluvia
 
 ```
 > node -v
-v20.10.0
+v20.12.2
 
 > npm -v
-10.2.3
+10.5.0
 
 > yarn -v
 1.22.21

biome.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.6.4/schema.json",
+  "organizeImports": {
+    "enabled": true
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true
+    }
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "lineWidth": 150
+  },
+  "javascript": {
+    "formatter": {
+      "enabled": true,
+      "quoteStyle": "single",
+      "jsxQuoteStyle": "double",
+      "trailingComma": "none",
+      "semicolons": "always",
+      "arrowParentheses": "always"
+    },
+    "parser": {
+      "unsafeParameterDecoratorsEnabled": true
+    }
+  },
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  }
+}

package.json

@@ -57,10 +57,11 @@
   ],
   "scripts": {
     "build": "yarn clean && tsc -b tsconfig.compilation.json",
-    "check": "tsc --noEmit",
+    "check": "biome check --apply src/*",
     "clean": "rimraf dist",
     "commit": "git cz",
-    "format": "eslint --fix 'src/**/*.{ts,tsx}'",
+    "format": "biome format --write src/*",
+    "lint": "biome lint --apply src/*",
     "prepare": "is-ci || husky install",
     "release": "semantic-release",
     "test": "vitest",
@@ -72,9 +73,9 @@
     "@jamashita/anden": "2.7.0"
   },
   "devDependencies": {
+    "@biomejs/biome": "1.6.4",
     "@commitlint/cli": "18.4.4",
     "@commitlint/config-conventional": "18.4.4",
-    "@jamashita/eslint-plugin": "1.99.0",
     "@semantic-release/changelog": "6.0.3",
     "@semantic-release/commit-analyzer": "11.1.0",
     "@semantic-release/git": "10.0.1",

src/address/AAddress.ts

@@ -1,7 +1,7 @@
 import { Objet } from '@jamashita/anden/object';
-import { BinaryPredicate, ForEach, Mapping, Nullable } from '@jamashita/anden/type';
-import { NarrowingBinaryPredicate, Quantity } from '../collection/index.js';
-import { Address } from './Address.js';
+import type { BinaryPredicate, ForEach, Mapping, Nullable } from '@jamashita/anden/type';
+import { type NarrowingBinaryPredicate, Quantity } from '../collection/index.js';
+import type { Address } from './Address.js';
 
 export abstract class AAddress<out V> extends Quantity<void, V> implements Address<V> {
   protected readonly address: Map<V | string, V>;
@@ -55,11 +55,11 @@ export abstract class AAddress<out V> extends Quantity<void, V> implements Addre
   protected filterInternal<W extends V = V>(predicate: NarrowingBinaryPredicate<V, W, void>): Map<W | string, W> {
     const m: Map<W | string, W> = new Map();
 
-    this.address.forEach((value: V) => {
-      if (predicate(value, undefined)) {
-        m.set(Quantity.genKey(value), value);
+    for (const [, v] of this.address) {
+      if (predicate(v, undefined)) {
+        m.set(Quantity.genKey(v), v);
       }
-    });
+    }
 
     return m;
   }
@@ -77,9 +77,9 @@ export abstract class AAddress<out V> extends Quantity<void, V> implements Addre
   }
 
   public forEach(foreach: ForEach<void, V>): void {
-    this.address.forEach((v: V) => {
+    for (const [, v] of this.address) {
       foreach(v);
-    });
+    }
   }
 
   public get(): null {
@@ -90,7 +90,9 @@ export abstract class AAddress<out V> extends Quantity<void, V> implements Addre
     return this.address.has(Quantity.genKey(value));
   }
 
+  // biome-ignore lint/suspicious/noConfusingVoidType: <explanation>
   public iterator(): IterableIterator<[void, V]> {
+    // biome-ignore lint/suspicious/noConfusingVoidType: <explanation>
     const iterable: Array<[void, V]> = [];
 
     for (const [, v] of this.address) {
@@ -102,24 +104,24 @@ export abstract class AAddress<out V> extends Quantity<void, V> implements Addre
 
   protected mapInternal<W>(mapping: Mapping<V, W>): Map<W | string, W> {
     const m: Map<W | string, W> = new Map();
-    let i: number = 0;
+    let i = 0;
 
-    this.address.forEach((value: V) => {
-      const w: W = mapping(value, i);
+    for (const [, v] of this.address) {
+      const w: W = mapping(v, i);
 
       m.set(Quantity.genKey(w), w);
       i++;
-    });
+    }
 
     return m;
   }
 
   public serialize(): string {
     const props: Array<string> = [];
 
-    this.forEach((element: V) => {
-      props.push(Objet.identify(element));
-    });
+    for (const [, v] of this.address) {
+      props.push(Objet.identify(v));
+    }
 
     return props.join(', ');
   }

src/address/Address.ts

@@ -1,6 +1,6 @@
-import { BinaryPredicate, Mapping } from '@jamashita/anden/type';
-import { NarrowingBinaryPredicate } from '../collection/index.js';
-import { ReadonlyAddress } from './ReadonlyAddress.js';
+import type { BinaryPredicate, Mapping } from '@jamashita/anden/type';
+import type { NarrowingBinaryPredicate } from '../collection/index.js';
+import type { ReadonlyAddress } from './ReadonlyAddress.js';
 
 export interface Address<out V> extends ReadonlyAddress<V> {
   add(value: V): Address<V>;

src/address/AddressUtil.ts

@@ -1,39 +1,41 @@
-import { Reject, Resolve, UnaryFunction } from '@jamashita/anden/type';
-import { Address } from './Address.js';
-import { ReadonlyAddress } from './ReadonlyAddress.js';
+import type { Reject, Resolve, UnaryFunction } from '@jamashita/anden/type';
+import type { Address } from './Address.js';
+import type { ReadonlyAddress } from './ReadonlyAddress.js';
 
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-export class AddressUtil {
-  public static await<V, A extends Address<V>>(address: ReadonlyAddress<PromiseLike<V>>, callback: UnaryFunction<Set<V>, A>): Promise<A> {
+export namespace AddressUtil {
+  export const wait = <V, A extends Address<V>>(address: ReadonlyAddress<PromiseLike<V>>, callback: UnaryFunction<Set<V>, A>): Promise<A> => {
     if (address.isEmpty()) {
       return Promise.resolve(callback(new Set()));
     }
 
-    let rejected: boolean = false;
+    let rejected = false;
     const set: Set<V> = new Set();
 
     return new Promise((resolve: Resolve<A>, reject: Reject) => {
-      address.forEach((value: PromiseLike<V>) => {
-        value.then((v: V) => {
-          if (rejected) {
-            return;
-          }
+      for (const value of address.values()) {
+        value.then(
+          (v: V) => {
+            if (rejected) {
+              return;
+            }
 
-          set.add(v);
+            set.add(v);
 
-          if (set.size === address.size()) {
-            resolve(callback(set));
-          }
-        }, (e: unknown) => {
-          if (rejected) {
-            return;
-          }
+            if (set.size === address.size()) {
+              resolve(callback(set));
+            }
+          },
+          (e: unknown) => {
+            if (rejected) {
+              return;
+            }
 
-          rejected = true;
+            rejected = true;
 
-          reject(e);
-        });
-      });
+            reject(e);
+          }
+        );
+      }
     });
-  }
+  };
 }

src/address/ImmutableAddress.ts

@@ -1,14 +1,14 @@
-import { BinaryPredicate, Mapping } from '@jamashita/anden/type';
-import { Collection, NarrowingBinaryPredicate, Quantity } from '../collection/index.js';
+import type { BinaryPredicate, Mapping } from '@jamashita/anden/type';
+import { type Collection, type NarrowingBinaryPredicate, Quantity } from '../collection/index.js';
 import { AAddress } from './AAddress.js';
 import { AddressUtil } from './AddressUtil.js';
-import { ReadonlyAddress } from './ReadonlyAddress.js';
+import type { ReadonlyAddress } from './ReadonlyAddress.js';
 
 export class ImmutableAddress<out V> extends AAddress<V> {
   private static readonly EMPTY: ImmutableAddress<unknown> = new ImmutableAddress(new Map());
 
   public static await<V>(address: ReadonlyAddress<PromiseLike<V>>): Promise<ImmutableAddress<V>> {
-    return AddressUtil.await(address, (values: Set<V>) => {
+    return AddressUtil.wait(address, (values: Set<V>) => {
       return ImmutableAddress.ofSet(values);
     });
   }
@@ -34,9 +34,9 @@ export class ImmutableAddress<out V> extends AAddress<V> {
   public static ofSet<V>(set: ReadonlySet<V>): ImmutableAddress<V> {
     const m: Map<V | string, V> = new Map();
 
-    set.forEach((v: V) => {
+    for (const v of set) {
       m.set(Quantity.genKey(v), v);
-    });
+    }
 
     return ImmutableAddress.ofInternal(m);
   }

src/address/MutableAddress.ts

@@ -1,12 +1,12 @@
-import { BinaryPredicate, Mapping } from '@jamashita/anden/type';
-import { Collection, NarrowingBinaryPredicate, Quantity } from '../collection/index.js';
+import type { BinaryPredicate, Mapping } from '@jamashita/anden/type';
+import { type Collection, type NarrowingBinaryPredicate, Quantity } from '../collection/index.js';
 import { AAddress } from './AAddress.js';
 import { AddressUtil } from './AddressUtil.js';
-import { ReadonlyAddress } from './ReadonlyAddress.js';
+import type { ReadonlyAddress } from './ReadonlyAddress.js';
 
 export class MutableAddress<out V> extends AAddress<V> {
   public static await<V>(address: ReadonlyAddress<PromiseLike<V>>): Promise<MutableAddress<V>> {
-    return AddressUtil.await(address, (values: Set<V>) => {
+    return AddressUtil.wait(address, (values: Set<V>) => {
       return MutableAddress.ofSet(values);
     });
   }
@@ -28,9 +28,9 @@ export class MutableAddress<out V> extends AAddress<V> {
   public static ofSet<V>(set: ReadonlySet<V>): MutableAddress<V> {
     const m: Map<V | string, V> = new Map();
 
-    set.forEach((v: V) => {
+    for (const v of set) {
       m.set(Quantity.genKey(v), v);
-    });
+    }
 
     return MutableAddress.ofInternal(m);
   }

src/address/ReadonlyAddress.ts

@@ -1,5 +1,5 @@
-import { BinaryPredicate, Cloneable, Mapping } from '@jamashita/anden/type';
-import { Collection, NarrowingBinaryPredicate } from '../collection/index.js';
+import type { BinaryPredicate, Cloneable, Mapping } from '@jamashita/anden/type';
+import type { Collection, NarrowingBinaryPredicate } from '../collection/index.js';
 
 export interface ReadonlyAddress<out V> extends Collection<void, V>, Cloneable<ReadonlyAddress<V>> {
   filter<W extends V>(predicate: NarrowingBinaryPredicate<V, W, void>): ReadonlyAddress<W>;