functionalscript 0.14.8 → 0.16.0

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

@@ -1,5 +1,3 @@
-import { boolean, number, string, bigint, unknown, or, never } from "./module.f.js";
-import { assertEq } from "../../dev/module.f.js";
 const tests = {
     undefined: [undefined],
     boolean: [true, false],
@@ -9,115 +7,10 @@ const tests = {
     object: [null, {}, []],
     function: [() => undefined]
 };
-const variantsOf = (t) => {
-    if (typeof t !== 'function') {
-        throw 'expected an or thunk';
-    }
-    const info = t();
-    if (info[0] !== 'or') {
-        throw `expected an or thunk, got ${info[0]}`;
-    }
-    return info.slice(1);
-};
 export default {
     typeof: Object.fromEntries(Object.entries(tests).map(([k, a]) => [k, a.map(v => () => {
             if (typeof v !== k) {
                 throw `typeof ${v} !== ${k}`;
             }
         })])),
-    or: {
-        flatten: {
-            shallow: () => {
-                const v = variantsOf(or(or(boolean, number), string));
-                assertEq(v.length, 3);
-                assertEq(v[0], boolean);
-                assertEq(v[1], number);
-                assertEq(v[2], string);
-            },
-            deep: () => {
-                assertEq(variantsOf(or(or(or(boolean, number), string), bigint)).length, 4);
-            },
-            manualOrThunk: () => {
-                // Manually-constructed `() => ['or', ...]` thunks should also flatten.
-                const inner = () => ['or', boolean, number];
-                assertEq(variantsOf(or(inner, string)).length, 3);
-            },
-            selfReferential: () => {
-                // A self-referential `or` thunk terminates: it is expanded once,
-                // then kept as-is on the second encounter (via the visited set).
-                const t = (() => ['or', boolean, t]);
-                // expansion: t -> [boolean, t]; t (second) kept as-is; number kept.
-                assertEq(variantsOf(or(t, number)).length, 3);
-            },
-        },
-        unknownCollapse: {
-            withConst: () => {
-                const v = variantsOf(or(unknown, 42));
-                assertEq(v.length, 1);
-                assertEq(v[0], unknown);
-            },
-            withThunk: () => {
-                const v = variantsOf(or(number, unknown, string));
-                assertEq(v.length, 1);
-                assertEq(v[0], unknown);
-            },
-            nested: () => {
-                // nested `or` whose flattening surfaces an `unknown`
-                const v = variantsOf(or(or(boolean, unknown), 42));
-                assertEq(v.length, 1);
-                assertEq(v[0], unknown);
-            },
-        },
-        dropPrimitiveSubset: {
-            number: () => {
-                const v = variantsOf(or(42, number));
-                assertEq(v.length, 1);
-                assertEq(v[0], number);
-            },
-            boolean: () => {
-                const v = variantsOf(or(true, false, boolean));
-                assertEq(v.length, 1);
-                assertEq(v[0], boolean);
-            },
-            string: () => {
-                const v = variantsOf(or('hi', 'bye', string));
-                assertEq(v.length, 1);
-                assertEq(v[0], string);
-            },
-            bigint: () => {
-                const v = variantsOf(or(7n, bigint));
-                assertEq(v.length, 1);
-                assertEq(v[0], bigint);
-            },
-            keepIfThunkAbsent: () => {
-                // Without a matching primitive thunk, consts are kept.
-                assertEq(variantsOf(or(42, 'hello')).length, 2);
-            },
-            mixed: () => {
-                // `null`/`undefined` consts have no matching primitive thunk and remain.
-                assertEq(variantsOf(or(null, undefined, 42, number)).length, 3);
-            },
-        },
-        dedup: {
-            sameThunkReference: () => {
-                assertEq(variantsOf(or(boolean, boolean)).length, 1);
-            },
-            samePrimitive: () => {
-                assertEq(variantsOf(or(42, 42)).length, 1);
-            },
-            nanCollapses: () => {
-                // `Object.is(NaN, NaN)` is true, so duplicate `NaN` variants
-                // collapse — matching `constPrimitiveValidate` semantics.
-                assertEq(variantsOf(or(NaN, NaN)).length, 1);
-            },
-            signedZeroDistinct: () => {
-                // `Object.is(+0, -0)` is false, so they remain distinct.
-                assertEq(variantsOf(or(0, -0)).length, 2);
-            },
-        },
-        emptyStillNever: () => {
-            assertEq(variantsOf(or()).length, 0);
-            assertEq(variantsOf(never).length, 0);
-        },
-    },
 };

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

@@ -6,9 +6,7 @@ export type Info0Ts<T extends Tag0> = T extends 'boolean' ? boolean : T extends
 /** Maps a `Const` schema to its TypeScript type. */
 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;
+} ? StructTs<T> : 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 array schema `T` to `readonly Ts<T>[]`. */
@@ -19,10 +17,14 @@ export type RecordTs<T extends Type> = ReadonlyRecord<string, Ts<T>>;
 export type TupleTs<T extends Tuple> = {
     readonly [K in keyof T]: Ts<T[K]>;
 };
-/** 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]>;
+type OptionalFields<T extends Struct> = {
+    readonly [K in keyof T as undefined extends Ts<T[K]> ? K : never]?: Ts<T[K]>;
+};
+type RequiredFields<T extends Struct> = {
+    readonly [K in keyof T as undefined extends Ts<T[K]> ? never : K]: Ts<T[K]>;
 };
+/** Maps a struct schema to a readonly object of resolved types, with optional fields for schemas that include `undefined`. */
+export type StructTs<T extends Struct> = (keyof OptionalFields<T> extends never ? unknown : OptionalFields<T>) & (keyof RequiredFields<T> extends never ? unknown : RequiredFields<T>);
 /**
  * Converts a schema `Type` to its corresponding TypeScript type.
  *
@@ -70,3 +72,4 @@ export type Ts<T extends Type> = T extends () => infer I ? (I extends readonly [
  * ```
  */
 export declare const printer: (mut?: true) => (rtti: Type) => string;
+export {};

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

@@ -1,80 +1,4 @@
-/**
- * Runtime validation of unknown values against RTTI schemas.
- *
- * The main entry point is `validate(rtti)`, which takes a schema `Type` and returns
- * a `Validate<T>` function. When called with an unknown value, it returns a `Result`
- * that is either `['ok', typedValue]` or `['error', { path, message }]`.
- *
- * ## Error path
- *
- * On failure, the error carries a `path` pointing at the offending sub-value:
- * each step is the string property name (for structs/records) or the stringified
- * index (for tuples/arrays). The path is empty when the failure is at the root.
- *
- * ## Dispatch strategy
- *
- * - **`Thunk`** schemas are evaluated lazily: the thunk is called once to obtain an
- *   `Info` descriptor, then dispatched by tag:
- *   - `'const'` — delegates to `constValidate`
- *   - `'unknown'` — always succeeds (any DJS value is valid)
- *   - `Tag1` (`'array'`, `'record'`) — delegates to `containerValidate`
- *   - `Tag0` (`'boolean'`, `'number'`, `'string'`, `'bigint'`) — uses `typeof` check
- *   - `'or'` — tries each variant; reports `'no match'` at the current location if all fail
- * - **`Const`** schemas (primitives, tuples, structs) validate by exact equality or
- *   recursive field/element checking.
- *
- * ## Recursion safety
- *
- * For `array` and `record` schemas, the inner item validator is instantiated lazily —
- * only after confirming the container is non-empty. This prevents infinite recursion
- * when validating recursive schemas like `const list = () => ['array', list]`.
- *
- * @module
- */
-import type { Unknown } from '../../../djs/module.f.ts';
-import { type Info0, type Primitive0, type Type } from '../module.f.ts';
-import { type Error, type Result as CommonResult } from '../../result/module.f.ts';
-import type { Ts } from '../ts/module.f.ts';
-import type { Primitive } from '../../../djs/module.f.ts';
-/** A path to a sub-value within the validated structure. Each step is an object key or stringified array index. */
-export type Path = readonly string[];
-/** Detailed validation failure: the offending `path` plus a short `message`. */
-export type ValidationError = {
-    readonly path: Path;
-    readonly message: string;
-};
-/** Validation result: either the typed value or a `ValidationError`. */
-export type Result<T extends Type> = CommonResult<Ts<T>, ValidationError>;
-/** A function that validates an unknown value against schema `T`. */
-export type Validate<T extends Type> = (value: Unknown) => Result<T>;
-/** Builds an error result with empty path and the given message. */
-export declare const verror: (message: string) => Error<ValidationError>;
-/** Prepends `key` to the error's path, used to build the path bottom-up. */
-export declare const prependPath: (key: string, r: Error<ValidationError>) => Error<ValidationError>;
-/** Validates a `Tag0` primitive schema using `typeof`. */
-export declare const primitive0Validate: <K extends Primitive0, T extends Info0<K>>(tag: K) => Validate<T>;
-/**
- * Validates a primitive `Const` schema using `Object.is` (SameValue).
- *
- * `Object.is` is used instead of `===` so that:
- * - `NaN` const schemas match `NaN` values (`===` would always fail because `NaN !== NaN`).
- * - `+0` and `-0` are treated as distinct const values.
- */
-export declare const constPrimitiveValidate: <T extends Primitive>(rtti: T) => Validate<T>;
-/**
- * Creates a validator function for the given RTTI schema.
- *
- * @param rtti - A schema `Type`: a `Thunk` for tag-based schemas, or a `Const`
- *   (primitive literal, tuple, or struct) for exact-value schemas.
- * @returns A `Validate<T>` function that checks an unknown value and returns
- *   `['ok', value]` or `['error', { path, message }]`.
- *
- * @example
- * ```ts
- * const v = validate(array(number))
- * v([1, 2, 3])         // ['ok', [1, 2, 3]]
- * v([1, 'two'])        // ['error', { path: ['1'], message: 'unexpected value' }]
- * v(['a'])             // ['error', { path: ['0'], message: 'unexpected value' }]
- * ```
- */
+import { type Type } from '../module.f.ts';
+import { type Validate } from '../common/module.f.ts';
+export { constPrimitiveValidate, prependPath, primitive0Validate, verror, type Path, type Result, type Validate, type ValidationError, } from '../common/module.f.ts';
 export declare const validate: <T extends Type>(rtti: T) => Validate<T>;

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

@@ -1,11 +1,9 @@
 import {} from "../module.f.js";
-import { error, ok } from "../../result/module.f.js";
+import { ok } from "../../result/module.f.js";
 import { isArray as commonIsArray } from "../../array/module.f.js";
 import { isObject as commonIsObject } from "../../object/module.f.js";
-/** Builds an error result with empty path and the given message. */
-export const verror = (message) => error({ path: [], message });
-/** Prepends `key` to the error's path, used to build the path bottom-up. */
-export const prependPath = (key, r) => error({ path: [key, ...r[1].path], message: r[1].message });
+import { constPrimitiveValidate, prependPath, primitive0Validate, verror, visit, } from "../common/module.f.js";
+export { constPrimitiveValidate, prependPath, primitive0Validate, verror, } from "../common/module.f.js";
 /**
  * Builds a validator for `array` or `record` schemas.
  * The inner item validator is instantiated lazily (only when the container is
@@ -35,8 +33,6 @@ const arrayEntries = (value) => value.map((v, i) => [String(i), v]);
 const arrayValidate = containerValidate(isArray, arrayEntries);
 const isObject = value => commonIsObject(value);
 const recordValidate = containerValidate(isObject, Object.entries);
-/** Validates a `Tag0` primitive schema using `typeof`. */
-export const primitive0Validate = (tag) => value => typeof value === tag ? ok(value) : verror('unexpected value');
 /**
  * Builds a validator for `Tuple` or `Struct` const schemas.
  * Iterates over the schema's entries and validates each corresponding
@@ -57,22 +53,6 @@ const constContainerValidate = (isContainer, getItem) => (rtti) => value => {
 };
 const tupleValidate = constContainerValidate(isArray, (value, k) => value[Number(k)]);
 const structValidate = constContainerValidate(isObject, (value, k) => value[k]);
-const constObjectValidate = (rtti) => commonIsArray(rtti)
-    ? tupleValidate(rtti)
-    : structValidate(rtti);
-/**
- * Validates a primitive `Const` schema using `Object.is` (SameValue).
- *
- * `Object.is` is used instead of `===` so that:
- * - `NaN` const schemas match `NaN` values (`===` would always fail because `NaN !== NaN`).
- * - `+0` and `-0` are treated as distinct const values.
- */
-export const constPrimitiveValidate = (rtti) => value => Object.is(rtti, value)
-    ? ok(value)
-    : verror('unexpected value');
-const constValidate = (rtti) => typeof rtti === 'object' && rtti !== null
-    ? constObjectValidate(rtti)
-    : constPrimitiveValidate(rtti);
 const orValidate = (rtti) => {
     const all = rtti.map(r => validate(r));
     return value => {
@@ -101,17 +81,14 @@ const orValidate = (rtti) => {
  * v(['a'])             // ['error', { path: ['0'], message: 'unexpected value' }]
  * ```
  */
-export const validate = (rtti) => {
-    if (typeof rtti === 'function') {
-        const [tag, ...value] = rtti();
-        switch (tag) {
-            case 'const': return constValidate(value[0]);
-            case 'array': return arrayValidate(value[0]);
-            case 'record': return recordValidate(value[0]);
-            case 'unknown': return ok;
-            case 'or': return orValidate(value);
-        }
-        return primitive0Validate(tag);
-    }
-    return constValidate(rtti);
+const validateVisitor = {
+    tuple: tupleValidate,
+    struct: structValidate,
+    array: arrayValidate,
+    record: recordValidate,
+    or: orValidate,
+    constPrimitive: constPrimitiveValidate,
+    primitive0: primitive0Validate,
+    unknown: () => ok,
 };
+export const validate = (rtti) => visit(validateVisitor)(rtti);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.14.8",
+  "version": "0.16.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -18,7 +18,7 @@
     "website": "node --experimental-strip-types ./fs/fjs/module.ts r ./fs/website/module.f.ts"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "bin": {
     "fjs": "fs/fjs/module.js"