functionalscript 0.12.0 → 0.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "type": "module",
   "files": [
     "**/*.js",

package/types/rtti/module.f.d.ts

@@ -1,46 +1,9 @@
-/**
- * Runtime type information (RTTI) — a type-safe schema system for describing and
- * converting TypeScript types.
- *
- * ## Core concepts
- *
- * A `Type` is either a `Const` (used directly as its own schema) or a `Thunk`
- * (a zero-argument function returning an `Info` descriptor). Thunks are the
- * primary building block: they enable lazy evaluation and recursive type definitions.
- *
- * ```
- * Type = Const | Thunk
- * Thunk = () => Info
- * Info = ['const', Const] | Info0<Tag0> | Info1<Tag1, Type>
- * ```
- *
- * ## Nullary schemas (no type parameter)
- *
- * `boolean`, `number`, `string`, `bigint`, `unknown` are pre-built `Thunk` values
- * that describe primitive types. Each is a `Type0<Tag0>` — a thunk returning a
- * single-element tag tuple.
- *
- * ## Unary schemas (one type parameter)
- *
- * `array(t)` and `record(t)` construct `Thunk` values parameterized by an inner
- * `Type`. They return `Type1` thunks wrapping an `Info1` tuple.
- *
- * ## Const schemas
- *
- * Any `Primitive`, `Struct` (plain object), or `Tuple` (readonly array) can be
- * used directly as a schema — it describes exactly the shape of that value.
- * Inside a recursive `Thunk`-based definition, wrap consts with `() => ['const', c]`
- * to keep the schema uniform.
- *
- * ## Converting to TypeScript types
- *
- * See `./ts/module.f.ts` for `Ts<T>` and the `*Ts` transformer types.
- */
-import type { Primitive } from '../../djs/module.f.ts';
 import { type Includes } from '../array/module.f.ts';
-export type ConstObject = Struct | Tuple;
 /** A constant schema: a primitive literal, a struct object, or a tuple. */
-export type Const = Primitive | ConstObject;
+export type Const = null | boolean | number | string | undefined | bigint | {
+    readonly [K in string]: Type;
+} | readonly Type[];
+export type ConstObject = Struct | Tuple;
 /** A struct schema: plain object whose values are nested `Type`s. */
 export type Struct = {
     readonly [K in string]: Type;
@@ -53,7 +16,7 @@ export declare const tag0List: readonly ["bigint", "boolean", "number", "string"
 /** Tags for nullary (zero-parameter) type schemas. */
 export type Tag0 = typeof tag0List[number];
 /** Info tuple for a nullary tag: `readonly[tag]`. */
-export type Info0<T extends Tag0> = readonly [T];
+export type Info0<T extends Tag0> = T extends Tag0 ? readonly [T] : never;
 /**
  * The descriptor returned by a `Thunk`. One of:
  * - `['const', Const]` — a constant/literal schema (used in recursive thunks)
@@ -64,7 +27,7 @@ export type Info = readonly ['const', Const] | Info0<Tag0> | Info1<Tag1, Type>;
 /** A lazy schema: a zero-argument function returning an `Info` descriptor. */
 export type Thunk = () => Info;
 /** Any schema: a `Const` used directly, or a `Thunk` for tag-based/recursive schemas. */
-export type Type = Const | Thunk;
+export type Type = (() => (readonly ['const', Const] | readonly ['bigint'] | readonly ['boolean'] | readonly ['number'] | readonly ['string'] | readonly ['unknown'] | readonly ['array', Type] | readonly ['record', Type])) | Const;
 /** The type of a nullary thunk for `Tag0`. */
 type Type0<T extends Tag0> = () => Info0<T>;
 /** Schema type for `boolean`. */
@@ -92,7 +55,7 @@ export declare const isTag1: Includes<string, typeof tag1List>;
 /** Tags for unary (one-parameter) type schemas. */
 export type Tag1 = typeof tag1List[number];
 /** Info tuple for a unary tag: `readonly[tag, innerType]`. */
-export type Info1<K extends Tag1, T extends Type> = readonly [K, T];
+export type Info1<K extends Tag1, T extends Type> = K extends Tag1 ? readonly [K, T] : never;
 /** The type of a unary thunk for `Tag1` with inner type `T`. */
 export type Type1<K extends Tag1, T extends Type> = () => Info1<K, T>;
 type MakeType1<K extends Tag1> = <T extends Type>(t: T) => Type1<K, T>;

package/types/rtti/ts/module.f.d.ts

@@ -1,10 +1,14 @@
-import type { Primitive, Unknown as DjsUnknown } from '../../../djs/module.f.ts';
+import type { Unknown as DjsUnknown } from '../../../djs/module.f.ts';
 import type { Tag0, Tag1, Const, Struct, Tuple, Info0, Info1, Info, Type } from '../module.f.ts';
 import type { ReadonlyRecord } from '../../object/module.f.ts';
 /** Maps a `Tag0` to its TypeScript type. */
 export type Info0Ts<T extends Tag0> = T extends 'boolean' ? boolean : T extends 'number' ? number : T extends 'string' ? string : T extends 'bigint' ? bigint : T extends 'unknown' ? DjsUnknown : never;
 /** Maps a `Const` schema to its TypeScript type. */
-export type ConstTs<T extends Const> = T extends Primitive ? T : T extends Tuple ? TupleTs<T> : T extends Struct ? StructTs<T> : never;
+export type ConstTs<T> = T extends readonly Type[] ? TupleTs<T> : T extends {
+    readonly [k in string]: Type;
+} ? {
+    readonly [K in keyof T]: Ts<T[K]>;
+} : T;
 /** Maps a `Tag1` and inner type to its TypeScript type. */
 export type Info1Ts<K extends Tag1, T extends Type> = K extends 'array' ? ArrayTs<T> : K extends 'record' ? RecordTs<T> : never;
 /** Maps an `Info` descriptor to its TypeScript type. */
@@ -13,11 +17,10 @@ export type InfoTs<T extends Info> = T extends readonly ['const', infer C extend
 export type ArrayTs<T extends Type> = ReadonlyArray<Ts<T>>;
 /** Maps a record schema `T` to `{ readonly[K in string]: Ts<T> }`. */
 export type RecordTs<T extends Type> = ReadonlyRecord<string, Ts<T>>;
-export type ClosedTupleTs<T extends Tuple> = {
+/** Maps a tuple schema to a readonly tuple of resolved types. */
+export type TupleTs<T extends Tuple> = {
     readonly [K in keyof T]: Ts<T[K]>;
 };
-/** Maps a tuple schema to a readonly tuple of resolved types. */
-export type TupleTs<T extends Tuple> = ClosedTupleTs<T>;
 /** Maps a struct schema to a readonly object of resolved types. */
 export type StructTs<T extends Struct> = {
     readonly [K in keyof T]: Ts<T[K]>;
@@ -36,4 +39,6 @@ export type StructTs<T extends Struct> = {
  * type D = Ts<{ x: typeof boolean }>  // { readonly x: boolean }
  * ```
  */
-export type Ts<T extends Type> = T extends () => (infer I extends Info) ? InfoTs<I> : T extends Const ? ConstTs<T> : never;
+export type Ts<T extends Type> = T extends () => infer I ? (I extends readonly ['const', infer C] ? ConstTs<C> : I extends readonly ['boolean'] ? boolean : I extends readonly ['number'] ? number : I extends readonly ['string'] ? string : I extends readonly ['bigint'] ? bigint : I extends readonly ['unknown'] ? DjsUnknown : I extends readonly ['array', infer E extends Type] ? readonly Ts<E>[] : I extends readonly ['record', infer E extends Type] ? {
+    readonly [K in string]: Ts<E>;
+} : never) : ConstTs<T>;

package/types/rtti/ts/module.f.js

@@ -1 +1 @@
-import { string, unknown } from "../module.f.js";
+export {};

package/types/rtti/validate/module.f.js

@@ -95,6 +95,16 @@ const constValidate = (rtti) => typeof rtti === 'object' && rtti !== null
  * v(['a', 'b'])  // ['error', 'unexpected value']
  * ```
  */
-export const validate = (rtti) => typeof rtti === 'function'
-    ? thunkValidate(rtti)
-    : constValidate(rtti);
+export const validate = (rtti) => {
+    if (typeof rtti === 'function') {
+        const [tag, value] = rtti();
+        switch (tag) {
+            case 'const': return constValidate(value);
+            case 'array': return arrayValidate(value);
+            case 'record': return recordValidate(value);
+            case 'unknown': return ok;
+        }
+        return primitive0Validate(tag);
+    }
+    return constValidate(rtti);
+};

package/types/rtti/validate/test.f.js

@@ -19,21 +19,27 @@ export default {
         },
     },
     number: {
-        ok: () => assertOk(validate(number)(42)),
+        ok: () => {
+            assertOk(validate(number)(42));
+        },
         error: () => {
             assertError(validate(number)('42'));
             assertError(validate(number)(42n));
         },
     },
     string: {
-        ok: () => assertOk(validate(string)('hello')),
+        ok: () => {
+            assertOk(validate(string)('hello'));
+        },
         error: () => {
             assertError(validate(string)(42));
             assertError(validate(string)(null));
         },
     },
     bigint: {
-        ok: () => assertOk(validate(bigint)(4n)),
+        ok: () => {
+            assertOk(validate(bigint)(4n));
+        },
         error: () => {
             assertError(validate(bigint)(4));
             assertError(validate(bigint)('4'));
@@ -51,34 +57,49 @@ export default {
     },
     const: {
         null: {
-            ok: () => assertOk(validate(null)(null)),
+            ok: () => {
+                assertOk(validate(null)(null));
+            },
             error: () => {
                 assertError(validate(null)(undefined));
                 assertError(validate(null)(0));
             },
         },
         undefined: {
-            ok: () => assertOk(validate(undefined)(undefined)),
+            ok: () => {
+                assertOk(validate(undefined)(undefined));
+            },
             error: () => assertError(validate(undefined)(null)),
         },
         number: {
-            ok: () => assertOk(validate(42)(42)),
+            ok: () => {
+                assertOk(validate(42)(42));
+            },
             error: () => assertError(validate(42)(43)),
         },
         string: {
-            ok: () => assertOk(validate('hello')('hello')),
+            ok: () => {
+                assertOk(validate('hello')('hello'));
+            },
             error: () => assertError(validate('hello')('world')),
         },
         bigint: {
-            ok: () => assertOk(validate(7n)(7n)),
+            ok: () => {
+                assertOk(validate(7n)(7n));
+            },
             error: () => assertError(validate(7n)(8n)),
         },
         boolean: {
-            ok: () => assertOk(validate(true)(true)),
+            ok: () => {
+                assertOk(validate(true)(true));
+            },
             error: () => assertError(validate(true)(false)),
         },
         tuple: {
-            ok: () => assertOk(validate([42, 'hello'])([42, 'hello'])),
+            ok: () => {
+                const t = [42, 'hello'];
+                assertOk(validate(t)([42, 'hello']));
+            },
             extraItems: () => assertOk(validate([42])([42, 'extra'])),
             error: () => {
                 assertError(validate([42])([99]));
@@ -86,7 +107,10 @@ export default {
             },
         },
         struct: {
-            ok: () => assertOk(validate({ a: 42, b: 'hello' })({ a: 42, b: 'hello' })),
+            ok: () => {
+                const t = { a: 42, b: 'hello' };
+                assertOk(validate(t)({ a: 42, b: 'hello' }));
+            },
             extraKeys: () => assertOk(validate({ a: 42 })({ a: 42, b: 'extra' })),
             error: () => {
                 assertError(validate({ a: 42 })({ a: 99 }));
@@ -96,20 +120,27 @@ export default {
     },
     array: {
         empty: () => assertOk(validate(array(number))([])),
-        ok: () => assertOk(validate(array(number))([1, 2, 3])),
+        ok: () => {
+            const t = array(number);
+            assertOk(validate(array(number))([1, 2, 3]));
+        },
         error: () => {
             assertError(validate(array(number))([1, 'two', 3]));
             assertError(validate(array(number))({}));
             assertError(validate(array(number))(null));
         },
         nested: () => {
+            const t = array(array(boolean));
             assertOk(validate(array(array(boolean)))([[true, false], [false]]));
             assertError(validate(array(array(boolean)))([[true, 42]]));
         },
     },
     record: {
         empty: () => assertOk(validate(record(number))({})),
-        ok: () => assertOk(validate(record(string))({ a: 'hello', b: 'world' })),
+        ok: () => {
+            const t = record(string);
+            assertOk(validate(t)({ a: 'hello', b: 'world' }));
+        },
         error: () => {
             assertError(validate(record(number))({ a: 1, b: 'two' }));
             assertError(validate(record(number))(null));
@@ -118,26 +149,28 @@ export default {
     },
     constThunk: {
         primitive: () => {
-            assertOk(validate(() => ['const', 7n])(7n));
-            assertError(validate(() => ['const', 7n])(8n));
+            const t = () => ['const', 7n];
+            assertOk(validate(t)(7n));
+            assertError(validate(t)(8n));
         },
     },
     recursive: {
         arrayOfArrays: () => {
             // self-referential schema: an array whose elements are also arrays of the same type
             const list = () => ['array', list];
-            // @ts-ignore see issue # 127
-            assertOk(validate(list)([]));
-            assertOk(validate(list)([[], []]));
-            assertOk(validate(list)([[[], []], []]));
-            assertError(validate(list)([42]));
-            assertError(validate(list)(null));
+            const v = validate(list);
+            assertOk(v([]));
+            assertOk(v([[], []]));
+            assertOk(v([[[], []], []]));
+            assertError(v([42]));
+            assertError(v(null));
         },
         recordOfRecords: () => {
             const tree = () => ['record', tree];
-            assertOk(validate(tree)({}));
-            assertOk(validate(tree)({ a: {}, b: { c: {} } }));
-            assertError(validate(tree)({ a: 42 }));
+            const v = validate(tree);
+            assertOk(v({}));
+            assertOk(v({ a: {}, b: { c: {} } }));
+            assertError(v({ a: 42 }));
         },
     },
 };