npm - functionalscript - Versions diffs - 0.11.10 → 0.12.0 - Mend

functionalscript 0.11.10 → 0.12.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

package/html/module.f.js +5 -2
package/json/module.f.d.ts +0 -1
package/json/module.f.js +4 -1
package/package.json +1 -1
package/types/array/module.f.d.ts +3 -0
package/types/array/module.f.js +2 -0
package/types/object/module.f.d.ts +6 -2
package/types/object/module.f.js +2 -0
package/types/rtti/module.f.d.ts +107 -0
package/types/rtti/module.f.js +21 -0
package/types/rtti/test.f.d.ts +6 -0
package/types/rtti/test.f.js +22 -0
package/types/rtti/ts/module.f.d.ts +39 -0
package/types/rtti/ts/module.f.js +1 -0
package/types/rtti/validate/module.f.d.ts +50 -0
package/types/rtti/validate/module.f.js +100 -0
package/types/rtti/validate/test.f.d.ts +76 -0
package/types/rtti/validate/test.f.js +143 -0
package/types/ts/module.f.d.ts +2 -0
package/types/ts/module.f.js +1 -0

package/html/module.f.js CHANGED Viewed

@@ -2,6 +2,7 @@ import { map, flatMap, flat, concat as listConcat } from "../types/list/module.f
 import { concat, concat as stringConcat } from "../types/string/module.f.js";
 import { compose } from "../types/function/module.f.js";
 import { stringToList } from "../text/utf16/module.f.js";
+import { includes } from "../types/array/module.f.js";
 const { fromCharCode } = String;
 const { entries } = Object;
 /**
@@ -62,6 +63,8 @@ const parseElement = (e) => {
             [tag, item1, list] :
             [tag, {}, [item1, ...list]];
 };
+const isVoidTag = includes(voidTagList);
+const isRawText = includes(rawText);
 /**
  * Converts a FunctionalScript element into a list of HTML string chunks.
  *
@@ -71,10 +74,10 @@ const parseElement = (e) => {
 export const element = (e) => {
     const [tag, a, n] = parseElement(e);
     const open = flat([[`<`, tag], attributes(a), [`>`]]);
-    if (voidTagList.includes(tag)) {
+    if (isVoidTag(tag)) {
         return open;
     }
-    return flat([open, rawText.includes(tag) ? [rawMap(n)] : nodes(n), ['</', tag, '>']]);
+    return flat([open, isRawText(tag) ? [rawMap(n)] : nodes(n), ['</', tag, '>']]);
 };
 /**
  * Builds a complete HTML document by prepending `<!DOCTYPE html>`.

package/json/module.f.d.ts CHANGED Viewed

@@ -17,5 +17,4 @@ export declare const serialize: (mapEntries: MapEntries) => (value: Unknown) =>
  */
 export declare const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
 export declare const parse: (value: string) => Unknown;
-export declare const isObject: (value: Unknown) => value is Object;
 export {};

package/json/module.f.js CHANGED Viewed

@@ -60,4 +60,7 @@ export const serialize = sort => {
  */
 export const stringify = sort => compose(serialize(sort))(concat);
 export const parse = JSON.parse;
-export const isObject = (value) => typeof value === 'object' && value !== null && !(value instanceof Array);
+/*
+export const isObject = (value: Unknown): value is Object =>
+    typeof value === 'object' && value !== null && !(value instanceof Array)
+*/

package/package.json CHANGED Viewed

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

package/types/array/module.f.d.ts CHANGED Viewed

@@ -3,6 +3,7 @@
  *
  * @module
  */
+export declare const isArray: (value: unknown) => value is readonly unknown[];
 export type Array1<T> = readonly [T];
 export type Index1 = 0;
 export type Array2<T> = readonly [T, T];
@@ -37,3 +38,5 @@ export declare const splitLast: <T>(a: readonly T[]) => readonly [readonly T[],
  * we may minimize memory a number of memory allocations.
  */
 export declare const empty: readonly [];
+export type Includes<I, T extends readonly I[]> = (v: I) => v is T[number];
+export declare const includes: <I, T extends readonly I[]>(a: T) => (v: I) => v is T[number];

package/types/array/module.f.js CHANGED Viewed

@@ -4,6 +4,7 @@
  * @module
  */
 import { map } from "../nullable/module.f.js";
+export const isArray = (value) => value instanceof Array;
 export const isArray2 = (a) => a.length === 2;
 const uncheckTail = (a) => a.slice(1);
 const uncheckHead = (a) => a.slice(0, -1);
@@ -34,3 +35,4 @@ export const splitLast = (a) => {
  * we may minimize memory a number of memory allocations.
  */
 export const empty = [];
+export const includes = (a) => (v) => a.includes(v);

package/types/object/module.f.d.ts CHANGED Viewed

@@ -15,7 +15,7 @@ export declare const fromMap: <T>(m: OrderedMap<T>) => Map<T>;
  * https://stackoverflow.com/questions/57571664/typescript-type-for-an-object-with-only-one-key-no-union-type-allowed-as-a-key
  */
 export type OneKey<K extends string, V> = {
-    [P in K]: (Record<P, V> & Partial<Record<Exclude<K, P>, never>>) extends infer O ? {
+    [P in K]: (ReadonlyRecord<P, V> & Partial<ReadonlyRecord<Exclude<K, P>, never>>) extends infer O ? {
         [Q in keyof O]: O[Q];
     } : never;
 }[K];
@@ -25,4 +25,8 @@ export type OneKey<K extends string, V> = {
 export type NotUnion<T, U = T> = T extends unknown ? [
     U
 ] extends [T] ? T : never : never;
-export type SingleProperty<T extends Record<string, never>> = keyof T extends NotUnion<keyof T> ? T : never;
+export type SingleProperty<T extends ReadonlyRecord<string, never>> = keyof T extends NotUnion<keyof T> ? T : never;
+export declare const isObject: (value: unknown) => value is { readonly [k in string]: unknown; };
+export type ReadonlyRecord<S extends string, T> = {
+    readonly [K in S]: T;
+};

package/types/object/module.f.js CHANGED Viewed

@@ -1,3 +1,4 @@
+import { isArray } from "../array/module.f.js";
 import { iterable } from "../list/module.f.js";
 import { entries as mapEntries, fromEntries as mapFromEntries } from "../ordered_map/module.f.js";
 const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object;
@@ -8,3 +9,4 @@ export const at = name => object => {
 export const sort = e => mapEntries(mapFromEntries(e));
 export const fromEntries = e => objectFromEntries(iterable(e));
 export const fromMap = m => fromEntries(mapEntries(m));
+export const isObject = (value) => typeof value === 'object' && !isArray(value) && value !== null;

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

@@ -0,0 +1,107 @@
+/**
+ * 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;
+/** A struct schema: plain object whose values are nested `Type`s. */
+export type Struct = {
+    readonly [K in string]: Type;
+};
+/** A tuple schema: readonly array whose elements are nested `Type`s. */
+export type Tuple = readonly Type[];
+declare const primitive0List: readonly ["bigint", "boolean", "number", "string"];
+export type Primitive0 = typeof primitive0List[number];
+export declare const tag0List: readonly ["bigint", "boolean", "number", "string", "unknown"];
+/** 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];
+/**
+ * The descriptor returned by a `Thunk`. One of:
+ * - `['const', Const]` — a constant/literal schema (used in recursive thunks)
+ * - `Info0<Tag0>` — a nullary primitive tag
+ * - `Info1<Tag1, Type>` — a unary parametric tag with an inner type
+ */
+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;
+/** The type of a nullary thunk for `Tag0`. */
+type Type0<T extends Tag0> = () => Info0<T>;
+/** Schema type for `boolean`. */
+export type Boolean = Type0<'boolean'>;
+/** Schema that validates `boolean` values. */
+export declare const boolean: Boolean;
+/** Schema type for `number`. */
+export type Number = Type0<'number'>;
+/** Schema that validates `number` values. */
+export declare const number: Number;
+/** Schema type for `string`. */
+export type String = Type0<'string'>;
+/** Schema that validates `string` values. */
+export declare const string: String;
+/** Schema type for `bigint`. */
+export type Bigint = Type0<'bigint'>;
+/** Schema that validates `bigint` values. */
+export declare const bigint: Bigint;
+/** Schema type for any DJS value (`Primitive | UnknownRecord | UnknownArray`). */
+export type Unknown = Type0<'unknown'>;
+/** Schema that validates any DJS-compatible value. */
+export declare const unknown: Unknown;
+declare const tag1List: readonly ["array", "record"];
+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];
+/** 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>;
+/** Schema type for a readonly array with element type `T`. */
+export type Array<T extends Type> = Type1<'array', T>;
+/** Constructs a schema that validates `readonly Ts<T>[]`. */
+export declare const array: MakeType1<'array'>;
+/** Schema type for a record (index signature) with value type `T`. */
+export type Record<T extends Type> = Type1<'record', T>;
+/** Constructs a schema that validates `{ readonly[K in string]: Ts<T> }`. */
+export declare const record: MakeType1<'record'>;
+export {};

package/types/rtti/module.f.js ADDED Viewed

@@ -0,0 +1,21 @@
+import { includes } from "../array/module.f.js";
+const primitive0List = ['bigint', 'boolean', 'number', 'string'];
+export const tag0List = [...primitive0List, 'unknown'];
+const type0 = (tag) => () => [tag];
+/** Schema that validates `boolean` values. */
+export const boolean = type0('boolean');
+/** Schema that validates `number` values. */
+export const number = type0('number');
+/** Schema that validates `string` values. */
+export const string = type0('string');
+/** Schema that validates `bigint` values. */
+export const bigint = type0('bigint');
+/** Schema that validates any DJS-compatible value. */
+export const unknown = type0('unknown');
+const tag1List = ['array', 'record'];
+export const isTag1 = includes(tag1List);
+const type1 = (key) => t => () => [key, t];
+/** Constructs a schema that validates `readonly Ts<T>[]`. */
+export const array = type1('array');
+/** Constructs a schema that validates `{ readonly[K in string]: Ts<T> }`. */
+export const record = type1('record');

package/types/rtti/test.f.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+declare const _default: {
+    typeof: {
+        [k: string]: (() => void)[];
+    };
+};
+export default _default;

package/types/rtti/test.f.js ADDED Viewed

@@ -0,0 +1,22 @@
+const tests = {
+    undefined: [undefined],
+    boolean: [true, false],
+    string: ['hello'],
+    number: [3],
+    bigint: [4n],
+    object: [null, {}, []],
+    function: [() => undefined]
+};
+const assertOk = ([k]) => { if (k !== 'ok') {
+    throw 'expected ok';
+} };
+const assertError = ([k]) => { if (k !== 'error') {
+    throw 'expected error';
+} };
+export default {
+    typeof: Object.fromEntries(Object.entries(tests).map(([k, a]) => [k, a.map(v => () => {
+            if (typeof v !== k) {
+                throw `typeof ${v} !== ${k}`;
+            }
+        })])),
+};

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

@@ -0,0 +1,39 @@
+import type { Primitive, 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;
+/** 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. */
+export type InfoTs<T extends Info> = T extends readonly ['const', infer C extends Const] ? ConstTs<C> : T extends Info0<infer K extends Tag0> ? Info0Ts<K> : T extends Info1<infer K extends Tag1, infer I extends Type> ? Info1Ts<K, I> : never;
+/** Maps an array schema `T` to `readonly Ts<T>[]`. */
+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> = {
+    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]>;
+};
+/**
+ * Converts a schema `Type` to its corresponding TypeScript type.
+ *
+ * - `Thunk` → evaluates the returned `Info` via `InfoTs`
+ * - `Const` → resolves via `ConstTs` (primitives map to themselves; structs/tuples recurse)
+ *
+ * @example
+ * ```ts
+ * type A = Ts<typeof string>           // string
+ * type B = Ts<4>                       // 4
+ * type C = Ts<Array<typeof number>>    // readonly number[]
+ * 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;

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

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

package/types/rtti/validate/module.f.d.ts ADDED Viewed

@@ -0,0 +1,50 @@
+/**
+ * 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', message]`.
+ *
+ * ## 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
+ * - **`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 Type } from '../module.f.ts';
+import { type Result as CommonResult } from '../../result/module.f.ts';
+import type { Ts } from '../ts/module.f.ts';
+/** Validation result: either the typed value or an error message. */
+export type Result<T extends Type> = CommonResult<Ts<T>, string>;
+/** A function that validates an unknown value against schema `T`. */
+export type Validate<T extends Type> = (value: Unknown) => Result<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', message]`.
+ *
+ * @example
+ * ```ts
+ * const v = validate(array(number))
+ * v([1, 2, 3])   // ['ok', [1, 2, 3]]
+ * v(['a', 'b'])  // ['error', 'unexpected value']
+ * ```
+ */
+export declare const validate: <T extends Type>(rtti: T) => Validate<T>;

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

@@ -0,0 +1,100 @@
+import { isTag1 } from "../module.f.js";
+import { error, ok } from "../../result/module.f.js";
+import { isArray as commonIsArray } from "../../array/module.f.js";
+import { isObject as commonIsObject } from "../../object/module.f.js";
+import { identity } from "../../function/module.f.js";
+/**
+ * Builds a validator for `array` or `record` schemas.
+ * The inner item validator is instantiated lazily (only when the container is
+ * non-empty) to avoid infinite recursion with recursive schemas.
+ */
+const containerValidate = (isContainer, getItems) => (item) => value => {
+    if (!isContainer(value)) {
+        return error('unexpected value');
+    }
+    const items = getItems(value);
+    if (items.length === 0) {
+        return ok(value);
+    }
+    // Note: we shouldn't instantiate `itemValidate` until we make sure `items` is not empty.
+    //       Otherwise, we can get infinite recursion on empty arrays and objects
+    const itemValidate = validate(item);
+    for (const i of items) {
+        const r = itemValidate(i);
+        if (r[0] === 'error') {
+            return r;
+        }
+    }
+    return ok(value);
+};
+const isArray = value => commonIsArray(value);
+const arrayValidate = containerValidate(isArray, identity);
+const isObject = value => commonIsObject(value);
+const recordValidate = containerValidate(isObject, Object.values);
+const tag1Validate = ([tag, item]) => tag === 'array'
+    ? arrayValidate(item)
+    : recordValidate(item);
+/** Validates a `Tag0` primitive schema using `typeof`. */
+const primitive0Validate = (tag) => value => typeof value === tag ? ok(value) : error('unexpected value');
+/** Validates a `Thunk` schema by evaluating it once and dispatching on the resulting `Info` tag. */
+const thunkValidate = (rtti) => {
+    const info = rtti();
+    const [tag, value] = info;
+    switch (tag) {
+        case 'const':
+            return constValidate(value);
+        case 'unknown':
+            return ok;
+    }
+    return isTag1(tag)
+        ? tag1Validate(info)
+        : primitive0Validate(tag);
+};
+/**
+ * Builds a validator for `Tuple` or `Struct` const schemas.
+ * Iterates over the schema's entries and validates each corresponding
+ * element/property of the value.
+ */
+const constContainerValidate = (isContainer, getItem) => (rtti) => value => {
+    if (!isContainer(value)) {
+        return error('unexpected value');
+    }
+    for (const [k, v] of Object.entries(rtti)) {
+        const item = getItem(value, k);
+        const r = validate(v)(item);
+        if (r[0] === 'error') {
+            return r;
+        }
+    }
+    return ok(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 strict equality (`===`). */
+const constPrimitiveValidate = (rtti) => value => rtti === value
+    ? ok(value)
+    : error('unexpected value');
+const constValidate = (rtti) => typeof rtti === 'object' && rtti !== null
+    ? constObjectValidate(rtti)
+    : constPrimitiveValidate(rtti);
+/**
+ * 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', message]`.
+ *
+ * @example
+ * ```ts
+ * const v = validate(array(number))
+ * v([1, 2, 3])   // ['ok', [1, 2, 3]]
+ * v(['a', 'b'])  // ['error', 'unexpected value']
+ * ```
+ */
+export const validate = (rtti) => typeof rtti === 'function'
+    ? thunkValidate(rtti)
+    : constValidate(rtti);

package/types/rtti/validate/test.f.d.ts ADDED Viewed

@@ -0,0 +1,76 @@
+declare const _default: {
+    boolean: {
+        ok: () => void;
+        error: () => void;
+    };
+    number: {
+        ok: () => void;
+        error: () => void;
+    };
+    string: {
+        ok: () => void;
+        error: () => void;
+    };
+    bigint: {
+        ok: () => void;
+        error: () => void;
+    };
+    unknown: {
+        ok: () => void;
+    };
+    const: {
+        null: {
+            ok: () => void;
+            error: () => void;
+        };
+        undefined: {
+            ok: () => void;
+            error: () => void;
+        };
+        number: {
+            ok: () => void;
+            error: () => void;
+        };
+        string: {
+            ok: () => void;
+            error: () => void;
+        };
+        bigint: {
+            ok: () => void;
+            error: () => void;
+        };
+        boolean: {
+            ok: () => void;
+            error: () => void;
+        };
+        tuple: {
+            ok: () => void;
+            extraItems: () => void;
+            error: () => void;
+        };
+        struct: {
+            ok: () => void;
+            extraKeys: () => void;
+            error: () => void;
+        };
+    };
+    array: {
+        empty: () => void;
+        ok: () => void;
+        error: () => void;
+        nested: () => void;
+    };
+    record: {
+        empty: () => void;
+        ok: () => void;
+        error: () => void;
+    };
+    constThunk: {
+        primitive: () => void;
+    };
+    recursive: {
+        arrayOfArrays: () => void;
+        recordOfRecords: () => void;
+    };
+};
+export default _default;

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

@@ -0,0 +1,143 @@
+import { validate } from "./module.f.js";
+import { boolean, number, string, bigint, unknown, array, record } from "../module.f.js";
+const assertOk = ([k]) => { if (k !== 'ok') {
+    throw 'expected ok';
+} };
+const assertError = ([k]) => { if (k !== 'error') {
+    throw 'expected error';
+} };
+export default {
+    boolean: {
+        ok: () => {
+            assertOk(validate(boolean)(true));
+            assertOk(validate(boolean)(false));
+        },
+        error: () => {
+            assertError(validate(boolean)(0));
+            assertError(validate(boolean)('true'));
+            assertError(validate(boolean)(null));
+        },
+    },
+    number: {
+        ok: () => assertOk(validate(number)(42)),
+        error: () => {
+            assertError(validate(number)('42'));
+            assertError(validate(number)(42n));
+        },
+    },
+    string: {
+        ok: () => assertOk(validate(string)('hello')),
+        error: () => {
+            assertError(validate(string)(42));
+            assertError(validate(string)(null));
+        },
+    },
+    bigint: {
+        ok: () => assertOk(validate(bigint)(4n)),
+        error: () => {
+            assertError(validate(bigint)(4));
+            assertError(validate(bigint)('4'));
+        },
+    },
+    unknown: {
+        ok: () => {
+            assertOk(validate(unknown)(null));
+            assertOk(validate(unknown)(42));
+            assertOk(validate(unknown)('hello'));
+            assertOk(validate(unknown)(true));
+            assertOk(validate(unknown)({}));
+            assertOk(validate(unknown)([]));
+        },
+    },
+    const: {
+        null: {
+            ok: () => assertOk(validate(null)(null)),
+            error: () => {
+                assertError(validate(null)(undefined));
+                assertError(validate(null)(0));
+            },
+        },
+        undefined: {
+            ok: () => assertOk(validate(undefined)(undefined)),
+            error: () => assertError(validate(undefined)(null)),
+        },
+        number: {
+            ok: () => assertOk(validate(42)(42)),
+            error: () => assertError(validate(42)(43)),
+        },
+        string: {
+            ok: () => assertOk(validate('hello')('hello')),
+            error: () => assertError(validate('hello')('world')),
+        },
+        bigint: {
+            ok: () => assertOk(validate(7n)(7n)),
+            error: () => assertError(validate(7n)(8n)),
+        },
+        boolean: {
+            ok: () => assertOk(validate(true)(true)),
+            error: () => assertError(validate(true)(false)),
+        },
+        tuple: {
+            ok: () => assertOk(validate([42, 'hello'])([42, 'hello'])),
+            extraItems: () => assertOk(validate([42])([42, 'extra'])),
+            error: () => {
+                assertError(validate([42])([99]));
+                assertError(validate([42])({}));
+            },
+        },
+        struct: {
+            ok: () => assertOk(validate({ a: 42, b: 'hello' })({ a: 42, b: 'hello' })),
+            extraKeys: () => assertOk(validate({ a: 42 })({ a: 42, b: 'extra' })),
+            error: () => {
+                assertError(validate({ a: 42 })({ a: 99 }));
+                assertError(validate({ a: 42 })([]));
+            },
+        },
+    },
+    array: {
+        empty: () => assertOk(validate(array(number))([])),
+        ok: () => 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: () => {
+            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' })),
+        error: () => {
+            assertError(validate(record(number))({ a: 1, b: 'two' }));
+            assertError(validate(record(number))(null));
+            assertError(validate(record(number))([]));
+        },
+    },
+    constThunk: {
+        primitive: () => {
+            assertOk(validate(() => ['const', 7n])(7n));
+            assertError(validate(() => ['const', 7n])(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));
+        },
+        recordOfRecords: () => {
+            const tree = () => ['record', tree];
+            assertOk(validate(tree)({}));
+            assertOk(validate(tree)({ a: {}, b: { c: {} } }));
+            assertError(validate(tree)({ a: 42 }));
+        },
+    },
+};

package/types/ts/module.f.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
2	+ export type Assert<T extends true> = T;

package/types/ts/module.f.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};