@terrygonguet/utils 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -2,17 +2,11 @@
  * Behaviour is undefined when max < min
  */
 declare function clamp(value: number, min: number, max: number): number;
-type JSONReviver = (key: string, value: any) => any;
-/**
- * This function does no runtime type checking,
- * make sure that the parsed value is valid
- */
-declare function safeParse<T>(str: string, defaultValue: T, reviver?: JSONReviver): T;
-declare function composeJSONRevivers(...revivers: JSONReviver[]): JSONReviver;
 declare function createNoopProxy<T>(): T;
 declare function noop(): void;
 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 safe<T, Err = unknown>(f: () => T): [null, T] | [Err, null];
 
-export { clamp, composeJSONRevivers, createNoopProxy, exhaustive, hash, noop, range, safeParse };
+export { clamp, createNoopProxy, exhaustive, hash, noop, range, safe };

package/dist/index.js

@@ -2,21 +2,6 @@
 function clamp(value, min, max) {
   return Math.min(Math.max(value, min), max);
 }
-function safeParse(str, defaultValue, reviver) {
-  try {
-    return JSON.parse(str, reviver);
-  } catch (_) {
-    return defaultValue;
-  }
-}
-function composeJSONRevivers(...revivers) {
-  return function(key, value) {
-    for (const reviver of revivers) {
-      value = reviver(key, value);
-    }
-    return value;
-  };
-}
 function createNoopProxy() {
   const noop2 = () => proxy;
   const no = () => false;
@@ -50,13 +35,20 @@ function* range(start, end, step = 1) {
     yield i;
   }
 }
+function safe(f) {
+  try {
+    const result = f();
+    return [null, result];
+  } catch (error) {
+    return [error, null];
+  }
+}
 export {
   clamp,
-  composeJSONRevivers,
   createNoopProxy,
   exhaustive,
   hash,
   noop,
   range,
-  safeParse
+  safe
 };

package/dist/json.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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;
+
+export { safeParse };

package/dist/json.js

@@ -0,0 +1,11 @@
+// src/json.ts
+function safeParse(str, defaultValue, reviver) {
+  try {
+    return JSON.parse(str, reviver);
+  } catch (_) {
+    return defaultValue;
+  }
+}
+export {
+  safeParse
+};

package/dist/tableau.d.ts

@@ -0,0 +1,63 @@
+type Predicate<T> = (value: T, index: number, tableau: Tableau<T>) => boolean;
+type AssertPredicate<T, U extends T> = (value: T, index: number, tableau: Tableau<T>) => value is U;
+type Reducer<T, U> = (previousValue: U, currentValue: T, index: number, tableau: Tableau<T>) => U;
+type Mapper<T, U> = (value: T, index: number, tableau: Tableau<T>) => U;
+type Comparer<T> = (a: T, b: T) => number;
+type FlatTableau<Arr, Depth extends number> = {
+    done: Arr;
+    recur: Arr extends Tableau<infer InnerArr> ? FlatTableau<InnerArr, [
+        -1,
+        0,
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        12,
+        13,
+        14,
+        15,
+        16,
+        17,
+        18,
+        19,
+        20
+    ][Depth]> : Arr;
+}[Depth extends -1 ? "done" : "recur"];
+declare class Tableau<T> extends Array<T> {
+    constructor(length?: number);
+    i(idx: number): T | undefined;
+    ientries(): IterableIterator<[number, T]>;
+    ievery<U extends T>(predicate: AssertPredicate<T, U>, thisArg?: any): this is Tableau<U>;
+    ievery(predicate: Predicate<T>, thisArg?: any): boolean;
+    ifilter<U extends T>(predicate: AssertPredicate<T, U>, thisArg?: any): Tableau<U>;
+    ifilter(predicate: Predicate<T>, thisArg?: any): Tableau<T>;
+    ifind<U extends T>(predicate: AssertPredicate<T, U>, thisArg?: any): U | undefined;
+    ifind(predicate: Predicate<T>, thisArg?: any): T | undefined;
+    ifindIndex(predicate: Predicate<T>, thisArg?: any): number | undefined;
+    ifindLast<U extends T>(predicate: AssertPredicate<T, U>, thisArg?: any): U | undefined;
+    ifindLast(predicate: Predicate<T>, thisArg?: any): T | undefined;
+    ifindLastIndex(predicate: Predicate<T>, thisArg?: any): number | undefined;
+    iflat<Depth extends number = 1>(depth?: Depth): FlatTableau<T, Depth>;
+    iflatMap<U>(callback: Mapper<T, U | Tableau<U>>, thisArg?: any): Tableau<U>;
+    iindexOf(searchElement: T, fromIndex?: number): number | undefined;
+    ikeys(): IterableIterator<number>;
+    ilastIndexOf(searchElement: T, fromIndex?: number): number | undefined;
+    imap<U>(callbackFn: Mapper<T, U>, thisArg?: any): Tableau<U>;
+    ireduce<U>(callbackFn: Reducer<T, U>, initialValue: U): U;
+    ireduceRight<U>(callbackFn: Reducer<T, U>, initialValue: U): U;
+    isome(predicate: Predicate<T>, thisArg?: any): boolean;
+    isort(compareFn: Comparer<T>): Tableau<T>;
+    isplice(start: number, deleteCount?: number, ...items: T[]): Tableau<T>;
+    iwith(index: number, value: T): Tableau<T>;
+    static from<T>(source: Iterable<T> | ArrayLike<T>): Tableau<T>;
+    static of<T>(...elements: T[]): Tableau<T>;
+}
+
+export { Tableau };

package/dist/tableau.js

@@ -0,0 +1,125 @@
+// src/tableau.ts
+var Tableau = class _Tableau extends Array {
+  constructor(length) {
+    length == void 0 ? super() : super(length);
+  }
+  i(idx) {
+    if (idx == 0) throw new RangeError("Cannot access index 0 in a Tableau");
+    return this.at(idx - 1);
+  }
+  *ientries() {
+    for (let i = 0; i < this.length; i++) {
+      yield [i + 1, this[i]];
+    }
+  }
+  ievery(predicate, thisArg) {
+    return this.every((value, i) => predicate(value, i + 1, this), thisArg);
+  }
+  ifilter(predicate, thisArg) {
+    return this.filter((value, i) => predicate(value, i + 1, this), thisArg);
+  }
+  ifind(predicate, thisArg) {
+    return this.find((value, i) => predicate(value, i + 1, this), thisArg);
+  }
+  ifindIndex(predicate, thisArg) {
+    const idx = this.findIndex(
+      (value, i) => predicate(value, i + 1, this),
+      thisArg
+    );
+    return idx == -1 ? void 0 : idx + 1;
+  }
+  ifindLast(predicate, thisArg) {
+    return this.findLast(
+      (value, i) => predicate(value, i + 1, this),
+      thisArg
+    );
+  }
+  ifindLastIndex(predicate, thisArg) {
+    const idx = this.findLastIndex(
+      (value, i) => predicate(value, i + 1, this),
+      thisArg
+    );
+    return idx == -1 ? void 0 : idx + 1;
+  }
+  iflat(depth) {
+    return this.flat(depth);
+  }
+  iflatMap(callback, thisArg) {
+    return this.flatMap(
+      (value, i) => callback(value, i + 1, this),
+      thisArg
+    );
+  }
+  iindexOf(searchElement, fromIndex = 1) {
+    if (fromIndex == 0)
+      throw new RangeError("Cannot access index 0 in a Tableau");
+    const idx = this.indexOf(searchElement, fromIndex - 1);
+    return idx == -1 ? void 0 : idx + 1;
+  }
+  *ikeys() {
+    for (const key of this.keys()) {
+      yield key + 1;
+    }
+  }
+  ilastIndexOf(searchElement, fromIndex = this.length) {
+    if (fromIndex == 0)
+      throw new RangeError("Cannot access index 0 in a Tableau");
+    const idx = this.lastIndexOf(searchElement, fromIndex - 1);
+    return idx == -1 ? void 0 : idx + 1;
+  }
+  imap(callbackFn, thisArg) {
+    return this.map(
+      (value, i) => callbackFn(value, i + 1, this),
+      thisArg
+    );
+  }
+  ireduce(callbackFn, initialValue) {
+    return this.reduce(
+      (acc, cur, i) => callbackFn(acc, cur, i + 1, this),
+      initialValue
+    );
+  }
+  ireduceRight(callbackFn, initialValue) {
+    return this.reduceRight(
+      (acc, cur, i) => callbackFn(acc, cur, i + 1, this),
+      initialValue
+    );
+  }
+  isome(predicate, thisArg) {
+    return this.some((value, i) => predicate(value, i + 1, this), thisArg);
+  }
+  isort(compareFn) {
+    return this.toSorted(compareFn);
+  }
+  isplice(start, deleteCount, ...items) {
+    if (start == 0)
+      throw new RangeError("Cannot access index 0 in a Tableau");
+    return this.toSpliced(start - 1, deleteCount, ...items);
+  }
+  iwith(index, value) {
+    if (index == 0)
+      throw new RangeError("Cannot access index 0 in a Tableau");
+    return this.with(index - 1, value);
+  }
+  static from(source) {
+    if ("length" in source) {
+      const litanie = new _Tableau(source.length);
+      for (let i = 0; i < source.length; i++) {
+        litanie[i] = source[i];
+      }
+      return litanie;
+    } else {
+      const litanie = new _Tableau();
+      for (const element of source) {
+        litanie.push(element);
+      }
+      return litanie;
+    }
+  }
+  static of(...elements) {
+    return _Tableau.from(elements);
+  }
+};
+export {
+  Tableau
+};

package/package.json

@@ -1,7 +1,8 @@
 {
 	"name": "@terrygonguet/utils",
-	"version": "0.1.0",
+	"version": "0.2.0",
 	"type": "module",
+	"license": "MIT",
 	"scripts": {
 		"dev": "vite",
 		"build": "tsup",
@@ -19,6 +20,14 @@
 		"./async": {
 			"types": "./dist/async.d.ts",
 			"import": "./dist/async.js"
+		},
+		"./json": {
+			"types": "./dist/json.d.ts",
+			"import": "./dist/json.js"
+		},
+		"./tableau": {
+			"types": "./dist/tableau.d.ts",
+			"import": "./dist/tableau.js"
 		}
 	},
 	"devDependencies": {