tuple-ts 0.8.3 → 0.9.0

package/README.md

@@ -21,7 +21,7 @@ with optional slot labels:
 ```ts
 import { struct } from "tuple-ts";
 
-const Person = struct(["name", "age"]);
+const Person = struct("name", "age");
 
 const person1 = Person("Bob", 25);
 
@@ -146,12 +146,12 @@ mat1 === mat2; // true
 ## Structs
 
 Use `struct()` when you want a tuple with meaningful labels.
-Provide a list of labels to create a reusable factory that produces tuples with additional named properties.
+Provide the labels to create a reusable factory that produces tuples with additional named properties.
 
 ```ts
 import { struct } from "tuple-ts";
 
-const Point = struct(["x", "y"]);
+const Point = struct("x", "y");
 
 const p = Point(10, 20);
 
@@ -171,7 +171,7 @@ Object.isFrozen(p); // true
 `.from()` accepts an object with the declared labels and creates the corresponding positional tuple:
 
 ```ts
-const Point = struct(["x", "y"]);
+const Point = struct("x", "y");
 
 const point1 = Point.from({ x: 10, y: 20 });
 
@@ -196,7 +196,7 @@ The returned value contains the tuple slots and the schema's named properties, n
 Just like `tuple`, structs support `.typed()` to specify the struct's value types positionally:
 
 ```ts
-const Point = struct(["x", "y"]).typed<[number, number]>();
+const Point = struct("x", "y").typed<[number, number]>();
 
 Point(10, 20);   // OK
 Point(10, "20"); // TypeScript error
@@ -207,7 +207,7 @@ Use `.typedFrom()` when you want to express the value types by label instead:
 ```ts
 type Coordinates = { x: number; y: number };
 
-const Point = struct(["x", "y"]).typedFrom<Coordinates>();
+const Point = struct("x", "y").typedFrom<Coordinates>();
 
 Point(10, 20);    // OK
 Point(10, "20");  // TypeScript error
@@ -217,19 +217,19 @@ Point.from({ x: 10, y: 20 }); // OK
 You can also provide a typed exemplar to `.typedFrom()`:
 
 ```ts
-const Point = struct(["x", "y"]).typedFrom({ x: 0, y: 0 });
+const Point = struct("x", "y").typedFrom({ x: 0, y: 0 });
 ```
 
 ### Struct schemas and identity
 
-Each call to `struct(labels)` creates its own cache. Factories narrowed from that schema with `.typed()` or `.typedFrom()` share the cache, but separate calls to `struct()` create separate caches, even when given identical labels:
+Each call to `struct(...)` creates its own identity context:
 
 ```ts
-const PointA = struct(["x", "y"]).typed<[number, number]>();
-const PointB = struct(["x", "y"]).typed<[number, number]>();
+const Point = struct("x", "y");
+Point(1, 2) === Point(1, 2); // true
 
-PointA(1, 2) === PointA(1, 2); // true
-PointA(1, 2) === PointB(1, 2); // false
+const Coord = struct("x", "y");
+Coord(1, 2) !== Point(1, 2); // true
 ```
 
 Struct identity is therefore scoped to the schema factory. Ordinary `tuple()` values use a separate, shared tuple cache and do not share identity with struct values, even when their indexed elements are equal.
@@ -262,7 +262,7 @@ myMap.set(tuple(10, 20), "visited");
 myMap.has(tuple(10, 20)); // true
 myMap.get(tuple(10, 20)); // "visited"
 
-const Point = struct(["x", "y"]);
+const Point = struct("x", "y");
 const mySet = new Set();
 mySet.add(Point(1, 2));
 
@@ -302,6 +302,10 @@ a === b; // true
 
 The cache uses `WeakRef` to avoid keeping interned objects alive solely because they are cached. A `FinalizationRegistry` is used to clean up cache entries after objects are garbage-collected. This allows unreferenced values to be reclaimed without the cache retaining them indefinitely.
 
+## Compatibility
+
+`tuple-ts` supports NodeJS version 20 or newer.
+
 ## License
 
 ISC

package/dist/index.d.ts

@@ -1,27 +1,27 @@
 import InternCache from "./intern-cache.js";
-type BaseTuple = readonly unknown[];
-type BaseLabels = readonly string[];
-type NumericKeyOf<T> = keyof T & `${number}`;
+type Tuple = readonly unknown[];
+type Labels = readonly string[];
+type NumericKeyOf<T> = keyof T & (number | `${number}`);
 type ToNumber<K> = K extends `${infer N extends number}` ? N : never;
-export type TupleFactory<T extends BaseTuple = BaseTuple> = {
+export type TupleFactory<T extends Tuple = Tuple> = {
     <const T_ extends T>(...args: T_): T_;
-    typed<T_ extends T>(...exemplar: T_ | []): TupleFactory<T_>;
+    typed<T_ extends T>(...exemplar: T_ | []): TupleFactory<Readonly<T_>>;
 };
-type ObjectOf<T extends BaseTuple, L extends BaseLabels> = {
+type ObjectOf<T extends Tuple, L extends Labels> = {
     [I in NumericKeyOf<L> as L[I]]: T[ToNumber<I>];
 };
-type TupleFromObject<T extends BaseTuple, L extends BaseLabels, O extends ObjectOf<T, L>> = T & {
+type TupleFromObject<T extends Tuple, L extends Labels, O extends ObjectOf<T, L>> = T & {
     [I in keyof L]: O[L[I]];
 };
-export type StructFactory<T extends BaseTuple, L extends BaseLabels> = {
+export type StructFactory<T extends Tuple, L extends Labels> = {
     <const T_ extends T>(...args: T_): Readonly<T_ & ObjectOf<T_, L>>;
     from<const O extends ObjectOf<T, L>, const T_ extends TupleFromObject<T, L, O>>(arg: O): Readonly<ObjectOf<T_, L> & T_>;
-    typed<T_ extends T>(...exemplar: T_ | []): StructFactory<T_, L>;
+    typed<T_ extends T>(...exemplar: T_ | []): StructFactory<Readonly<T_>, L>;
     typedFrom<O extends ObjectOf<T, L>>(...args: [exemplar: O] | []): StructFactory<{
         [I in keyof L]: O[L[I]];
     }, L>;
 };
 export declare const _tupleCache: InternCache<number, readonly unknown[], readonly unknown[]>;
-export declare const tuple: TupleFactory<BaseTuple>;
-export declare const struct: <const L extends readonly string[]>(labels: L) => StructFactory<BaseTuple, L>;
+export declare const tuple: TupleFactory<Tuple>;
+export declare const struct: <const L extends readonly string[]>(...labels: L) => StructFactory<Tuple, L>;
 export {};

package/dist/index.js

@@ -31,7 +31,7 @@ const defineStruct = (cache, labels) => {
 };
 export const _tupleCache = new InternCache(hash.valuesHash, arrayEquivalent, Object.freeze);
 export const tuple = defineTuple();
-export const struct = (labels) => {
+export const struct = (...labels) => {
     const cacheInjestFn = (tuple) => {
         labels.forEach((label, index) => {
             tuple[label] = tuple[index];

package/dist/intern-cache.js

@@ -1,10 +1,13 @@
 export default class {
+    hashFn;
+    matchFn;
+    injestFn;
+    map = new Map();
+    cleanupRegistry = new FinalizationRegistry((x) => this.remove(x));
     constructor(hashFn, matchFn, injestFn) {
         this.hashFn = hashFn;
         this.matchFn = matchFn;
         this.injestFn = injestFn;
-        this.map = new Map();
-        this.cleanupRegistry = new FinalizationRegistry((x) => this.remove(x));
     }
     remove([hash, valueRef]) {
         const hashBucket = this.map.get(hash);

package/dist/tuple-ts.min.js

@@ -0,0 +1 @@
+var u=class{constructor(e,n,t){this.hashFn=e;this.matchFn=n;this.injestFn=t}hashFn;matchFn;injestFn;map=new Map;cleanupRegistry=new FinalizationRegistry(e=>this.remove(e));remove([e,n]){let t=this.map.get(e);t&&(t.delete(n),t.size===0&&this.map.delete(e))}get(e){let n=this.hashFn(e),t=this.map.get(n);if(t!==void 0)for(let s of t){let T=s.deref();if(T&&this.matchFn(e,T))return T}else t=new Set,this.map.set(n,t);let r=this.injestFn(e),o=new WeakRef(r);return t.add(o),this.cleanupRegistry.register(r,[n,o],this),r}get size(){return Array.from(this.map.entries(),([e,n])=>n.size).reduce((e,n)=>e+n,0)}reset(){this.cleanupRegistry.unregister(this),this.map.clear()}};var g=0xffffffffn,m=new Float64Array(1),p=new Uint32Array(m.buffer);function j(e,n=0){let t=n,r=0;for(let o of e){r++;let s=Math.imul(o,3432918353);s=s<<15|s>>>17,s=Math.imul(s,461845907),t^=s,t=t<<13|t>>>19,t=Math.imul(t,5)+3864292196|0}return t^=r*4,t>>>0}function k(e=Date.now()){let n=e>>>0;return()=>(n=n*1664525+1013904223>>>0,n)}var a=k(),h=a(),F=a(),w=a(),R=a(),H=a(),I=a(),N=a(),K=a(),y=new WeakMap,M=new WeakMap;function l(e,n){if(n===null)return h;let t=e.get(n);if(t!==void 0)return t;let r=a();return e.set(n,r),r}function b(e){let n=Array(Math.ceil(e.length/2)+1);n[0]=e.length;for(let t=0;t<e.length/2;t+=1){let r=e.charCodeAt(2*t),o=e.charCodeAt(2*t+1);n[t+1]=o<<16|r}return n}function S(e){return m[0]=Number.isNaN(e)?NaN:e,[p[0],p[1]]}function V(e){let n=e<0n,t=n?-e:e,r=[n?1:0];for(;t!==0n;)r.push(Number(t&g)),t>>=32n;return r}function A(e){switch(typeof e){case"string":return i(b(e),N);case"number":return i(S(e),H);case"bigint":return i(V(e),I);case"boolean":return e?R:w;case"symbol":let n=Symbol.keyFor(e);return n===void 0?l(M,e):i(b(n),K);case"undefined":return F;case"object":return e===null?h:l(y,e);case"function":return l(y,e)}}var d=(e,n)=>i(Array.from(e,A),n),i=j;function O(e,n){if(n.length!==e.length)return!1;for(let t=0;t<e.length;t++)if(!Object.is(n[t],e[t]))return!1;return!0}var x=()=>Object.assign((...t)=>W.get(t),{typed:(...t)=>x()}),f=(e,n)=>{let t=(...c)=>e.get(c);return Object.assign((...c)=>t(...c),{from:c=>{let _=n.map(L=>c[L]);return t(..._)},typed:(...c)=>f(e,n),typedFrom:(...c)=>f(e,n)})},W=new u(d,O,Object.freeze),v=x(),E=(...e)=>{let n=r=>(e.forEach((o,s)=>{r[o]=r[s]}),Object.freeze(r)),t=new u(d,O,n);return f(t,e)};export{W as _tupleCache,E as struct,v as tuple};

package/package.json

@@ -1,8 +1,8 @@
 {
   "type": "module",
   "name": "tuple-ts",
-  "version": "0.8.3",
-  "description": "Tuples and structs for TypeScript and JavaScript with equality and identity semantics.",
+  "version": "0.9.0",
+  "description": "TypeScript-first tuples and structs with value-based identity",
   "keywords": [
     "tuple",
     "struct",
@@ -19,31 +19,32 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/geobrad/tuple-ts.git"
+    "url": "git+https://github.com/geobrad/tuple-ts.git"
   },
   "bugs": {
     "url": "https://github.com/geobrad/tuple-ts/issues"
   },
   "homepage": "https://github.com/geobrad/tuple-ts",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
+    "types": "./dist/index.d.ts",
+    "import": "./dist/index.js"
+  },
+  "engines": {
+    "node": ">=20.0.0"
   },
   "scripts": {
-    "build": "tsc",
-    "test": "tsc --noEmit && vitest run src/",
+    "build": "rm -r dist/ && tsc && esbuild src/index.ts --bundle --minify --format=esm --platform=browser --target=es2023 --outfile=dist/tuple-ts.min.js",
+    "test": "tsc -p tsconfig.test.json --noEmit && vitest run src/",
     "prepare": "npm run build",
     "prepublishOnly": "npm test"
   },
-  "author": "George Bradley",
+  "author": "George Bradley <george@gbrad.com> (https://gbrad.com/)",
   "license": "ISC",
   "devDependencies": {
+    "@types/node": "^26.6.5",
+    "esbuild": "^0.28.2",
     "typescript": "^7.0.2",
-    "vitest": "^5.0.5"
+    "vitest": "^4.1.12"
   },
   "files": [
     "./dist"