@terrygonguet/utils 0.7.1 → 0.9.0

package/dist/index.d.ts

@@ -8,8 +8,10 @@ declare function exhaustive(_: never): never;
 declare function hash(message: string): Promise<ArrayBuffer>;
 declare function range(start: number, end: number, step?: number): Generator<number, void, unknown>;
 declare function yesno(value?: string): boolean;
+declare function mapListPush<Key, T>(map: Map<Key, T[]>, key: Key, value: T): Map<Key, T[]>;
+declare function recordListPush<Key extends string, T>(record: Record<Key, T[]>, key: Key, value: T): Record<Key, T[]>;
 type ExecResult<T, Err = Error> = [null, T] | [Err, null];
 declare function tryCatch<F extends (...args: any) => any>(f: F, ...args: Parameters<F>): ReturnType<F> extends Promise<any> ? Promise<ExecResult<Awaited<ReturnType<F>>>> : ExecResult<ReturnType<F>>;
 declare function tryCatch<Err, F extends (...args: any) => any>(f: F, ...args: Parameters<F>): ReturnType<F> extends Promise<any> ? Promise<ExecResult<Awaited<ReturnType<F>>, Err>> : ExecResult<ReturnType<F>, Err>;
 
-export { type ExecResult, clamp, createNoopProxy, exhaustive, hash, noop, range, tryCatch, yesno };
+export { type ExecResult, clamp, createNoopProxy, exhaustive, hash, mapListPush, noop, range, recordListPush, tryCatch, yesno };

package/dist/index.js

@@ -47,6 +47,17 @@ function yesno(value) {
       return false;
   }
 }
+function mapListPush(map, key, value) {
+  const arr = map.get(key) ?? [];
+  arr.push(value);
+  return map.set(key, arr);
+}
+function recordListPush(record, key, value) {
+  const arr = record[key] ?? [];
+  arr.push(value);
+  record[key] = arr;
+  return record;
+}
 function tryCatch(f, ...args) {
   try {
     const promiseOrResult = f(...args);
@@ -65,8 +76,10 @@ export {
   createNoopProxy,
   exhaustive,
   hash,
+  mapListPush,
   noop,
   range,
+  recordListPush,
   tryCatch,
   yesno
 };

package/dist/json.d.ts

@@ -1,7 +1,28 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+
 /**
  * This function does no runtime type checking,
  * make sure that the parsed value is valid
  */
 declare function safeParse<T>(str: string, defaultValue: T, reviver?: (key: string, value: any) => any): T;
+type SchemaParseReturn<Schema extends StandardSchemaV1> = [parseError: Error, validationFailure: null, output: null] | [
+    parseError: null,
+    validationFailure: StandardSchemaV1.FailureResult,
+    output: null
+] | [
+    parseError: null,
+    validationFailure: null,
+    output: StandardSchemaV1.InferOutput<Schema>
+];
+declare function schemaParse<Schema extends StandardSchemaV1, Async extends boolean = false>(schema: Schema, str: string, options?: {
+    reviver?(key: string, value: any): any;
+    async?: Async;
+}): Async extends true ? Promise<SchemaParseReturn<Schema>> : SchemaParseReturn<Schema>;
+declare function schemaParseWithDefault<Schema extends StandardSchemaV1, Async extends boolean = false>(schema: Schema, str: string, defaultValue: StandardSchemaV1.InferOutput<Schema>, options?: {
+    reviver?(key: string, value: any): any;
+    async?: Async;
+    out_parseError?: Error[];
+    out_validationFailure?: StandardSchemaV1.FailureResult[];
+}): Async extends true ? Promise<StandardSchemaV1.InferOutput<Schema>> : StandardSchemaV1.InferOutput<Schema>;
 
-export { safeParse };
+export { safeParse, schemaParse, schemaParseWithDefault };

package/dist/json.js

@@ -6,6 +6,58 @@ function safeParse(str, defaultValue, reviver) {
     return defaultValue;
   }
 }
+function schemaParse(schema, str, options) {
+  try {
+    const parsed = JSON.parse(str, options?.reviver);
+    const result = schema["~standard"].validate(parsed);
+    if (options?.async) {
+      if (result instanceof Promise) {
+        return result.then(
+          (result2) => result2.issues ? [null, result2, null] : [null, null, result2.value],
+          (err) => [err, null, null]
+        );
+      } else {
+        return Promise.resolve(
+          result.issues ? [null, result, null] : [null, null, result.value]
+        );
+      }
+    } else {
+      if (result instanceof Promise)
+        throw new Error(
+          "Function schemaParse() whas called with an async schema but without the async flag"
+        );
+      else if (result.issues) return [null, result, null];
+      else return [null, null, result.value];
+    }
+  } catch (error) {
+    return [error, null, null];
+  }
+}
+function schemaParseWithDefault(schema, str, defaultValue, options) {
+  const result = schemaParse(schema, str, options);
+  if (result instanceof Promise) {
+    return result.then(([error, failure, value]) => {
+      if (failure) {
+        options?.out_validationFailure?.push(failure);
+        return defaultValue;
+      } else if (error) {
+        options?.out_parseError?.push(error);
+        return defaultValue;
+      } else return value;
+    });
+  } else {
+    const [error, failure, value] = result;
+    if (failure) {
+      options?.out_validationFailure?.push(failure);
+      return defaultValue;
+    } else if (error) {
+      options?.out_parseError?.push(error);
+      return defaultValue;
+    } else return value;
+  }
+}
 export {
-  safeParse
+  safeParse,
+  schemaParse,
+  schemaParseWithDefault
 };

package/dist/option.d.ts

@@ -0,0 +1,45 @@
+declare class Option<T> {
+    #private;
+    readonly _kind: "Some" | "None";
+    readonly value: T;
+    private constructor();
+    static do<T>(f: () => Iterator<Option<any>, T, any>): Option<T>;
+    static from<T>(maybeValue: unknown, { allowOptionLikePOJO }?: {
+        allowOptionLikePOJO?: boolean | undefined;
+    }): Option<T>;
+    static wrapFunction<T, Args extends any[]>(f: (...args: Args) => T | undefined | null, { allowOptionLikePOJO }?: {
+        allowOptionLikePOJO?: boolean | undefined;
+    }): (...args: Args) => Option<T>;
+    static isOption<T>(maybeOption: unknown): maybeOption is Option<T>;
+    static Some<T>(value: T): Option<T>;
+    static None<T>(): Option<T>;
+    [Symbol.iterator](): Iterator<Option<T>, T>;
+    [Symbol.toPrimitive](): string;
+    isSome(): boolean;
+    isNone(): boolean;
+    equals(other: Option<T>): boolean;
+    map<U>(f: (value: T) => U, { coalesce }?: {
+        coalesce?: boolean | undefined;
+    }): Option<U>;
+    flatMap<U>(f: (value: T) => Option<U>): Option<U>;
+    flatten(): T extends Option<infer U> ? Option<U> : Option<T>;
+    orDefault(defaultValue: T): T;
+    orNull(): T | null;
+    orUndefined(): T | undefined;
+    or<U>(other: Option<U>): Option<T> | Option<U>;
+    unwrap(): T;
+    filter<U extends T>(predicate: (value: T) => value is U): Option<U>;
+    filter(predicate: (value: T) => boolean): Option<T>;
+    toString(): string;
+}
+declare function arrayGet<T>(arr: T[], i: number): Option<T>;
+declare function arrayFind<T>(arr: T[], predicate: (item: T, i: number, arr: T[]) => boolean, thisArg?: any): Option<T>;
+declare function arrayFindLast<T>(arr: T[], predicate: (item: T, i: number, arr: T[]) => boolean, thisArg?: any): Option<T>;
+declare function arrayFindIndex<T>(arr: T[], predicate: (item: T, i: number, arr: T[]) => boolean, thisArg?: any): Option<number>;
+declare function arrayFindLastIndex<T>(arr: T[], predicate: (item: T, i: number, arr: T[]) => boolean, thisArg?: any): Option<number>;
+declare function arrayIndexOf<T>(arr: T[], item: T, fromIndex?: number): Option<number>;
+declare function arrayLastIndexOf<T>(arr: T[], item: T, fromIndex?: number): Option<number>;
+declare function arrPop<T>(arr: T[]): Option<T>;
+declare function arrShift<T>(arr: T[]): Option<T>;
+
+export { Option, arrPop, arrShift, arrayFind, arrayFindIndex, arrayFindLast, arrayFindLastIndex, arrayGet, arrayIndexOf, arrayLastIndexOf };

package/dist/option.js

@@ -0,0 +1,163 @@
+// src/option.ts
+var Option = class _Option {
+  _kind;
+  value;
+  constructor(_kind, value = void 0) {
+    this._kind = _kind;
+    this.value = value;
+  }
+  static do(f) {
+    const gen = f();
+    let iter = gen.next();
+    while (!iter.done) {
+      switch (iter.value._kind) {
+        case "Some":
+          iter = gen.next(iter.value.value);
+          break;
+        case "None":
+          gen.return?.(void 0);
+          return _Option.None();
+      }
+    }
+    return _Option.Some(iter.value);
+  }
+  static from(maybeValue, { allowOptionLikePOJO = false } = {}) {
+    if (maybeValue === void 0 || maybeValue === null)
+      return _Option.None();
+    else if (_Option.isOption(maybeValue)) return maybeValue;
+    else if (allowOptionLikePOJO && maybeValue && typeof maybeValue == "object" && "_kind" in maybeValue && (maybeValue._kind == "Some" || maybeValue._kind == "None"))
+      return new _Option(
+        maybeValue._kind,
+        maybeValue.value
+      );
+    else return _Option.Some(maybeValue);
+  }
+  static wrapFunction(f, { allowOptionLikePOJO = false } = {}) {
+    return (...args) => _Option.from(f(...args), { allowOptionLikePOJO });
+  }
+  static isOption(maybeOption) {
+    return maybeOption instanceof _Option;
+  }
+  static Some(value) {
+    return new _Option("Some", value);
+  }
+  static #None = new _Option("None");
+  static None() {
+    return this.#None;
+  }
+  *[Symbol.iterator]() {
+    yield this;
+    if (this.isNone())
+      throw new Error("Tried to unwrap a None() via its iterator");
+    else return this.value;
+  }
+  [Symbol.toPrimitive]() {
+    return this.toString();
+  }
+  isSome() {
+    return this._kind == "Some";
+  }
+  isNone() {
+    return this._kind == "None";
+  }
+  equals(other) {
+    if (this.isNone()) return other.isNone();
+    else if (other.isNone()) return false;
+    else return this.value == other.value;
+  }
+  map(f, { coalesce = false } = {}) {
+    if (this.isNone()) return _Option.None();
+    else if (coalesce) return _Option.from(f(this.value));
+    else return _Option.Some(f(this.value));
+  }
+  flatMap(f) {
+    if (this.isNone()) return _Option.None();
+    else return f(this.value);
+  }
+  flatten() {
+    if (this.isNone()) return _Option.None();
+    else return _Option.isOption(this.value) ? this.value : this;
+  }
+  orDefault(defaultValue) {
+    if (this.isNone()) return defaultValue;
+    else return this.value;
+  }
+  orNull() {
+    if (this.isNone()) return null;
+    else return this.value;
+  }
+  orUndefined() {
+    if (this.isNone()) return void 0;
+    else return this.value;
+  }
+  or(other) {
+    if (this.isNone()) return other;
+    else return this;
+  }
+  unwrap() {
+    if (this.isNone()) throw new Error("Tried to unwrap a None()");
+    else return this.value;
+  }
+  filter(predicate) {
+    if (this.isNone()) return this;
+    else return predicate(this.value) ? this : _Option.None();
+  }
+  toString() {
+    if (this.isNone()) return "None()";
+    switch (typeof this.value) {
+      case "string":
+        return `Some("${this.value}")`;
+      case "function":
+      case "object":
+        return `Some(${JSON.stringify(this.value)})`;
+      default:
+        return `Some(${this.value})`;
+    }
+  }
+};
+function arrayGet(arr, i) {
+  if (i >= arr.length || i < 0) return Option.None();
+  else return Option.Some(arr[i]);
+}
+function arrayFind(arr, predicate, thisArg) {
+  return Option.from(arr.find(predicate, thisArg));
+}
+function arrayFindLast(arr, predicate, thisArg) {
+  return Option.from(arr.findLast(predicate, thisArg));
+}
+function arrayFindIndex(arr, predicate, thisArg) {
+  const idx = arr.findIndex(predicate, thisArg);
+  return idx == -1 ? Option.None() : Option.Some(idx);
+}
+function arrayFindLastIndex(arr, predicate, thisArg) {
+  const idx = arr.findLastIndex(predicate, thisArg);
+  return idx == -1 ? Option.None() : Option.Some(idx);
+}
+function arrayIndexOf(arr, item, fromIndex) {
+  const idx = arr.indexOf(item, fromIndex);
+  return idx == -1 ? Option.None() : Option.Some(idx);
+}
+function arrayLastIndexOf(arr, item, fromIndex) {
+  const idx = arr.lastIndexOf(item, fromIndex);
+  return idx == -1 ? Option.None() : Option.Some(idx);
+}
+function arrPop(arr) {
+  if (arr.length == 0) return Option.None();
+  else return Option.Some(arr.pop());
+}
+function arrShift(arr) {
+  if (arr.length == 0) return Option.None();
+  else return Option.Some(arr.shift());
+}
+export {
+  Option,
+  arrPop,
+  arrShift,
+  arrayFind,
+  arrayFindIndex,
+  arrayFindLast,
+  arrayFindLastIndex,
+  arrayGet,
+  arrayIndexOf,
+  arrayLastIndexOf
+};

package/package.json

@@ -1,12 +1,12 @@
 {
 	"name": "@terrygonguet/utils",
-	"version": "0.7.1",
+	"version": "0.9.0",
 	"type": "module",
 	"license": "MIT",
 	"scripts": {
 		"dev": "vite",
 		"build": "tsup",
-		"test": "vitest test --update --typecheck"
+		"test": "vitest test --typecheck"
 	},
 	"files": [
 		"dist"
@@ -24,25 +24,31 @@
 			"types": "./dist/json.d.ts",
 			"import": "./dist/json.js"
 		},
+		"./option": {
+			"types": "./dist/option.d.ts",
+			"import": "./dist/option.js"
+		},
 		"./random": {
 			"types": "./dist/random.d.ts",
 			"import": "./dist/random.js"
 		},
-		"./tableau": {
-			"types": "./dist/tableau.d.ts",
-			"import": "./dist/tableau.js"
-		},
 		"./result": {
 			"types": "./dist/result.d.ts",
 			"import": "./dist/result.js"
+		},
+		"./tableau": {
+			"types": "./dist/tableau.d.ts",
+			"import": "./dist/tableau.js"
 		}
 	},
 	"devDependencies": {
-		"prettier": "^3.5.3",
-		"tsup": "^8.4.0",
-		"typescript": "^5.8.3",
-		"vite": "^6.3.5",
-		"vitest": "^3.1.3"
+		"@types/benchmark": "^2.1.5",
+		"benchmark": "^2.1.4",
+		"prettier": "^3.6.2",
+		"tsup": "^8.5.0",
+		"typescript": "^5.9.3",
+		"vite": "^6.3.6",
+		"vitest": "^3.2.4"
 	},
 	"author": {
 		"email": "terry@gonguet.com",
@@ -55,5 +61,8 @@
 	},
 	"bugs": {
 		"url": "https://github.com/terrygonguet/utils/issues"
+	},
+	"dependencies": {
+		"@standard-schema/spec": "^1.0.0"
 	}
 }