@nicolastoulemont/std 0.1.0

package/dist/data-DgzWI4R_.mjs

@@ -0,0 +1,244 @@
+import { a as deepEquals, i as createHashMethod, o as deepHash, r as createEqualsMethod } from "./equality-YMebYwm1.mjs";
+
+//#region src/data/data.tagged.ts
+/**
+* Create a tagged value constructor without schema validation.
+*
+* Unlike record(), this creates values directly without validation.
+* Values are frozen and have structural equality via equals() and hash() methods.
+*
+* @template T - The data shape type (excluding __typename)
+* @param typename - The __typename discriminator value
+* @returns A constructor function with is(), equals(), and hash() methods
+*
+* @see {@link record} for validated records with schema support
+* @see {@link struct} for untagged value objects
+*
+* @example
+* ```ts
+* const Person = tagged<{ name: string; age: number }>("Person")
+*
+* const alice = Person({ name: "Alice", age: 30 })
+* // => { __typename: "Person", name: "Alice", age: 30 }
+*
+* Person.equals(alice, Person({ name: "Alice", age: 30 })) // true
+* Person.is(alice) // true
+*
+* // Type guard usage
+* if (Person.is(unknownValue)) {
+*   console.log(unknownValue.name) // TypeScript knows it's a Person
+* }
+*
+* // Values are frozen (immutable)
+* alice.name = "Bob" // TypeError
+* ```
+*/
+function tagged(typename) {
+	const constructor = (input) => {
+		return Object.freeze({
+			...input,
+			__typename: typename
+		});
+	};
+	constructor.is = (value) => {
+		return typeof value === "object" && value !== null && "__typename" in value && value.__typename === typename;
+	};
+	constructor.equals = createEqualsMethod(typename);
+	constructor.hash = createHashMethod(typename);
+	constructor.__typename = typename;
+	return constructor;
+}
+
+//#endregion
+//#region src/data/data.struct.ts
+/**
+* Create a frozen value object with structural equality.
+*
+* Unlike tagged(), struct() does not add a __typename discriminator.
+* Use this for simple value objects that don't need discrimination.
+*
+* The returned object is frozen (immutable) and has non-enumerable
+* equals() and hash() methods for structural comparison.
+*
+* @template T - The object shape type
+* @param input - The object to wrap
+* @returns A frozen object with equals() and hash() methods
+*
+* @see {@link tagged} for discriminated value objects with __typename
+* @see {@link array} for array value types
+*
+* @example
+* ```ts
+* const point = struct({ x: 10, y: 20 })
+* const point2 = struct({ x: 10, y: 20 })
+*
+* point.equals(point2) // true
+* point.hash() // number
+*
+* // Object is frozen
+* point.x = 5 // TypeError
+*
+* // equals/hash are non-enumerable
+* Object.keys(point) // ["x", "y"]
+* ```
+*/
+function struct(input) {
+	const value = { ...input };
+	Object.defineProperty(value, "equals", {
+		value: (other) => deepEquals(value, other),
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	Object.defineProperty(value, "hash", {
+		value: () => deepHash(value),
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	return Object.freeze(value);
+}
+
+//#endregion
+//#region src/data/data.tuple.ts
+/**
+* Create a tuple with structural equality.
+*
+* The returned tuple is frozen (immutable) and has non-enumerable
+* equals() and hash() methods for structural comparison.
+*
+* @template T - The tuple type as a readonly array of element types
+* @param args - The tuple elements
+* @returns A frozen tuple-like array with equals() and hash() methods
+*
+* @see {@link array} for variable-length arrays with equality
+* @see {@link struct} for object value types
+*
+* @example
+* ```ts
+* const t1 = tuple(1, "hello", true)
+* const t2 = tuple(1, "hello", true)
+*
+* t1.equals(t2) // true
+* t1.hash() // number
+*
+* // Access elements (typed)
+* t1[0] // number
+* t1[1] // string
+* t1[2] // boolean
+*
+* // Tuple is frozen
+* t1[0] = 5 // TypeError
+* ```
+*/
+function tuple(...args) {
+	const value = [...args];
+	Object.defineProperty(value, "equals", {
+		value: (other) => deepEquals(value, other),
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	Object.defineProperty(value, "hash", {
+		value: () => deepHash(value),
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	return Object.freeze(value);
+}
+
+//#endregion
+//#region src/data/data.array.ts
+/**
+* Create an array with structural equality.
+*
+* The returned array is frozen (immutable) and has non-enumerable
+* equals() and hash() methods for structural comparison.
+*
+* The map() and filter() methods are overridden to return ArrayValue,
+* enabling method chaining with preserved equality semantics.
+*
+* @template T - The element type of the array
+* @param items - The array elements
+* @returns A frozen array with equals(), hash(), map(), and filter()
+*
+* @see {@link tuple} for fixed-length typed tuples
+* @see {@link struct} for object value types
+*
+* @example
+* ```ts
+* const arr1 = array([1, 2, 3])
+* const arr2 = array([1, 2, 3])
+*
+* arr1.equals(arr2) // true
+* arr1.hash() // number
+*
+* // Chainable operations return ArrayValue
+* arr1.map(x => x * 2) // ArrayValue<number>
+* arr1.filter(x => x > 1) // ArrayValue<number>
+*
+* // Chained equality check
+* arr1.map(x => x * 2).equals(array([2, 4, 6])) // true
+*
+* // Array is frozen
+* arr1[0] = 5 // TypeError
+* arr1.push(4) // TypeError
+* ```
+*/
+function array(items) {
+	const value = [...items];
+	Object.defineProperty(value, "equals", {
+		value: (other) => deepEquals(value, other),
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	Object.defineProperty(value, "hash", {
+		value: () => deepHash(value),
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	const originalMap = value.map.bind(value);
+	Object.defineProperty(value, "map", {
+		value: (fn) => {
+			return array(originalMap(fn));
+		},
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	const originalFilter = value.filter.bind(value);
+	Object.defineProperty(value, "filter", {
+		value: (fn) => {
+			return array(originalFilter(fn));
+		},
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	const originalSlice = value.slice.bind(value);
+	Object.defineProperty(value, "slice", {
+		value: (start, end) => {
+			return array(originalSlice(start, end));
+		},
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	const originalConcat = value.concat.bind(value);
+	Object.defineProperty(value, "concat", {
+		value: (...args) => {
+			return array(originalConcat(...args));
+		},
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	return Object.freeze(value);
+}
+
+//#endregion
+export { tagged as i, tuple as n, struct as r, array as t };
+//# sourceMappingURL=data-DgzWI4R_.mjs.map

package/dist/data-DgzWI4R_.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-DgzWI4R_.mjs","names":[],"sources":["../src/data/data.tagged.ts","../src/data/data.struct.ts","../src/data/data.tuple.ts","../src/data/data.array.ts"],"sourcesContent":["import { createEqualsMethod, createHashMethod } from \"../equality/equality\"\nimport type { Discriminator } from \"../shared/discriminator.types\"\nimport type { TaggedConstructor, TaggedValue } from \"./data.types\"\n\n/**\n * Create a tagged value constructor without schema validation.\n *\n * Unlike record(), this creates values directly without validation.\n * Values are frozen and have structural equality via equals() and hash() methods.\n *\n * @template T - The data shape type (excluding __typename)\n * @param typename - The __typename discriminator value\n * @returns A constructor function with is(), equals(), and hash() methods\n *\n * @see {@link record} for validated records with schema support\n * @see {@link struct} for untagged value objects\n *\n * @example\n * ```ts\n * const Person = tagged<{ name: string; age: number }>(\"Person\")\n *\n * const alice = Person({ name: \"Alice\", age: 30 })\n * // => { __typename: \"Person\", name: \"Alice\", age: 30 }\n *\n * Person.equals(alice, Person({ name: \"Alice\", age: 30 })) // true\n * Person.is(alice) // true\n *\n * // Type guard usage\n * if (Person.is(unknownValue)) {\n *   console.log(unknownValue.name) // TypeScript knows it's a Person\n * }\n *\n * // Values are frozen (immutable)\n * alice.name = \"Bob\" // TypeError\n * ```\n */\nexport function tagged<T extends Record<string, unknown>>(typename: string): TaggedConstructor<typeof typename, T> {\n  type Output = TaggedValue<typeof typename, T>\n\n  // Constructor function\n  const constructor = (input: T): Output => {\n    return Object.freeze({ ...input, __typename: typename }) as Output\n  }\n\n  // Type guard\n  constructor.is = (value: unknown): value is Output => {\n    return (\n      typeof value === \"object\" &&\n      value !== null &&\n      \"__typename\" in value &&\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Already checked with 'in' operator\n      (value as Discriminator).__typename === typename\n    )\n  }\n\n  // Equality (static method on constructor)\n  constructor.equals = createEqualsMethod<typeof typename, T>(typename)\n\n  // Hashing (static method on constructor)\n  constructor.hash = createHashMethod<typeof typename, T>(typename)\n\n  // Store typename for reflection\n  constructor.__typename = typename\n\n  return constructor as TaggedConstructor<typeof typename, T>\n}\n","import { deepEquals, deepHash } from \"../equality/equality\"\nimport type { StructValue } from \"./data.types\"\n\n/**\n * Create a frozen value object with structural equality.\n *\n * Unlike tagged(), struct() does not add a __typename discriminator.\n * Use this for simple value objects that don't need discrimination.\n *\n * The returned object is frozen (immutable) and has non-enumerable\n * equals() and hash() methods for structural comparison.\n *\n * @template T - The object shape type\n * @param input - The object to wrap\n * @returns A frozen object with equals() and hash() methods\n *\n * @see {@link tagged} for discriminated value objects with __typename\n * @see {@link array} for array value types\n *\n * @example\n * ```ts\n * const point = struct({ x: 10, y: 20 })\n * const point2 = struct({ x: 10, y: 20 })\n *\n * point.equals(point2) // true\n * point.hash() // number\n *\n * // Object is frozen\n * point.x = 5 // TypeError\n *\n * // equals/hash are non-enumerable\n * Object.keys(point) // [\"x\", \"y\"]\n * ```\n */\nexport function struct<T extends Record<string, unknown>>(input: T): StructValue<T> {\n  const value = { ...input }\n\n  // Add equals method (non-enumerable)\n  Object.defineProperty(value, \"equals\", {\n    value: (other: T) => deepEquals(value, other),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Add hash method (non-enumerable)\n  Object.defineProperty(value, \"hash\", {\n    value: () => deepHash(value),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic struct return type\n  return Object.freeze(value) as StructValue<T>\n}\n","import { deepEquals, deepHash } from \"../equality/equality\"\nimport type { TupleValue } from \"./data.types\"\n\n/**\n * Create a tuple with structural equality.\n *\n * The returned tuple is frozen (immutable) and has non-enumerable\n * equals() and hash() methods for structural comparison.\n *\n * @template T - The tuple type as a readonly array of element types\n * @param args - The tuple elements\n * @returns A frozen tuple-like array with equals() and hash() methods\n *\n * @see {@link array} for variable-length arrays with equality\n * @see {@link struct} for object value types\n *\n * @example\n * ```ts\n * const t1 = tuple(1, \"hello\", true)\n * const t2 = tuple(1, \"hello\", true)\n *\n * t1.equals(t2) // true\n * t1.hash() // number\n *\n * // Access elements (typed)\n * t1[0] // number\n * t1[1] // string\n * t1[2] // boolean\n *\n * // Tuple is frozen\n * t1[0] = 5 // TypeError\n * ```\n */\nexport function tuple<T extends readonly unknown[]>(...args: T): TupleValue<T> {\n  const value = [...args]\n\n  // Add equals method (non-enumerable)\n  Object.defineProperty(value, \"equals\", {\n    value: (other: readonly unknown[]) => deepEquals(value, other),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Add hash method (non-enumerable)\n  Object.defineProperty(value, \"hash\", {\n    value: () => deepHash(value),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic tuple return type\n  return Object.freeze(value) as unknown as TupleValue<T>\n}\n","import { deepEquals, deepHash } from \"../equality/equality\"\nimport type { ArrayValue } from \"./data.types\"\n\n/**\n * Create an array with structural equality.\n *\n * The returned array is frozen (immutable) and has non-enumerable\n * equals() and hash() methods for structural comparison.\n *\n * The map() and filter() methods are overridden to return ArrayValue,\n * enabling method chaining with preserved equality semantics.\n *\n * @template T - The element type of the array\n * @param items - The array elements\n * @returns A frozen array with equals(), hash(), map(), and filter()\n *\n * @see {@link tuple} for fixed-length typed tuples\n * @see {@link struct} for object value types\n *\n * @example\n * ```ts\n * const arr1 = array([1, 2, 3])\n * const arr2 = array([1, 2, 3])\n *\n * arr1.equals(arr2) // true\n * arr1.hash() // number\n *\n * // Chainable operations return ArrayValue\n * arr1.map(x => x * 2) // ArrayValue<number>\n * arr1.filter(x => x > 1) // ArrayValue<number>\n *\n * // Chained equality check\n * arr1.map(x => x * 2).equals(array([2, 4, 6])) // true\n *\n * // Array is frozen\n * arr1[0] = 5 // TypeError\n * arr1.push(4) // TypeError\n * ```\n */\nexport function array<T>(items: readonly T[]): ArrayValue<T> {\n  const value = [...items]\n\n  // Add equals method (non-enumerable)\n  Object.defineProperty(value, \"equals\", {\n    value: (other: readonly T[]) => deepEquals(value, other),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Add hash method (non-enumerable)\n  Object.defineProperty(value, \"hash\", {\n    value: () => deepHash(value),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override map to return ArrayValue\n  const originalMap = value.map.bind(value)\n  Object.defineProperty(value, \"map\", {\n    value: <U>(fn: (item: T, index: number, arr: readonly T[]) => U): ArrayValue<U> => {\n      return array(originalMap(fn))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override filter to return ArrayValue\n  const originalFilter = value.filter.bind(value)\n  Object.defineProperty(value, \"filter\", {\n    value: (fn: (item: T, index: number, arr: readonly T[]) => boolean): ArrayValue<T> => {\n      return array(originalFilter(fn))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override slice to return ArrayValue\n  const originalSlice = value.slice.bind(value)\n  Object.defineProperty(value, \"slice\", {\n    value: (start?: number, end?: number): ArrayValue<T> => {\n      return array(originalSlice(start, end))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override concat to return ArrayValue\n  const originalConcat = value.concat.bind(value)\n  Object.defineProperty(value, \"concat\", {\n    value: (...args: readonly (T | readonly T[])[]): ArrayValue<T> => {\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for concat argument spread\n      return array(originalConcat(...(args as T[][])))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic array return type\n  return Object.freeze(value) as unknown as ArrayValue<T>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,SAAgB,OAA0C,UAAyD;CAIjH,MAAM,eAAe,UAAqB;AACxC,SAAO,OAAO,OAAO;GAAE,GAAG;GAAO,YAAY;GAAU,CAAC;;AAI1D,aAAY,MAAM,UAAoC;AACpD,SACE,OAAO,UAAU,YACjB,UAAU,QACV,gBAAgB,SAEf,MAAwB,eAAe;;AAK5C,aAAY,SAAS,mBAAuC,SAAS;AAGrE,aAAY,OAAO,iBAAqC,SAAS;AAGjE,aAAY,aAAa;AAEzB,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC9BT,SAAgB,OAA0C,OAA0B;CAClF,MAAM,QAAQ,EAAE,GAAG,OAAO;AAG1B,QAAO,eAAe,OAAO,UAAU;EACrC,QAAQ,UAAa,WAAW,OAAO,MAAM;EAC7C,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;AAGF,QAAO,eAAe,OAAO,QAAQ;EACnC,aAAa,SAAS,MAAM;EAC5B,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;AAGF,QAAO,OAAO,OAAO,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACrB7B,SAAgB,MAAoC,GAAG,MAAwB;CAC7E,MAAM,QAAQ,CAAC,GAAG,KAAK;AAGvB,QAAO,eAAe,OAAO,UAAU;EACrC,QAAQ,UAA8B,WAAW,OAAO,MAAM;EAC9D,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;AAGF,QAAO,eAAe,OAAO,QAAQ;EACnC,aAAa,SAAS,MAAM;EAC5B,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;AAGF,QAAO,OAAO,OAAO,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACd7B,SAAgB,MAAS,OAAoC;CAC3D,MAAM,QAAQ,CAAC,GAAG,MAAM;AAGxB,QAAO,eAAe,OAAO,UAAU;EACrC,QAAQ,UAAwB,WAAW,OAAO,MAAM;EACxD,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;AAGF,QAAO,eAAe,OAAO,QAAQ;EACnC,aAAa,SAAS,MAAM;EAC5B,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;CAGF,MAAM,cAAc,MAAM,IAAI,KAAK,MAAM;AACzC,QAAO,eAAe,OAAO,OAAO;EAClC,QAAW,OAAwE;AACjF,UAAO,MAAM,YAAY,GAAG,CAAC;;EAE/B,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;CAGF,MAAM,iBAAiB,MAAM,OAAO,KAAK,MAAM;AAC/C,QAAO,eAAe,OAAO,UAAU;EACrC,QAAQ,OAA8E;AACpF,UAAO,MAAM,eAAe,GAAG,CAAC;;EAElC,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;CAGF,MAAM,gBAAgB,MAAM,MAAM,KAAK,MAAM;AAC7C,QAAO,eAAe,OAAO,SAAS;EACpC,QAAQ,OAAgB,QAAgC;AACtD,UAAO,MAAM,cAAc,OAAO,IAAI,CAAC;;EAEzC,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;CAGF,MAAM,iBAAiB,MAAM,OAAO,KAAK,MAAM;AAC/C,QAAO,eAAe,OAAO,UAAU;EACrC,QAAQ,GAAG,SAAuD;AAEhE,UAAO,MAAM,eAAe,GAAI,KAAe,CAAC;;EAElD,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;AAGF,QAAO,OAAO,OAAO,MAAM"}

package/dist/discriminator.types-DCkkrCj4.d.mts

@@ -0,0 +1,7 @@
+//#region src/shared/discriminator.types.d.ts
+type Discriminator<Typename extends string = string> = {
+  readonly __typename: Typename;
+};
+//#endregion
+export { Discriminator as t };
+//# sourceMappingURL=discriminator.types-DCkkrCj4.d.mts.map

package/dist/discriminator.types-DCkkrCj4.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discriminator.types-DCkkrCj4.d.mts","names":[],"sources":["../src/shared/discriminator.types.ts"],"sourcesContent":[],"mappings":";KAAY;EAAA,SAAA,UAAa,EAA4D,QAA5D"}

package/dist/either/index.d.mts

@@ -0,0 +1,2 @@
+import { r as Either$1, t as Either } from "../index-CvGTIg9L.mjs";
+export { Either, Either$1 as EitherType };

package/dist/either/index.mjs

@@ -0,0 +1,3 @@
+import { t as Either } from "../either-CnOBUH7a.mjs";
+
+export { Either };