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

functionalscript 0.11.10 → 0.11.11

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 (8) hide show

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/package.json CHANGED Viewed

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

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

@@ -37,3 +37,4 @@ 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 declare const includes: <I, T extends readonly I[]>(a: T) => (v: I) => v is T[number];

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

@@ -34,3 +34,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/rtti/module.f.d.ts ADDED Viewed

@@ -0,0 +1,48 @@
+import { type Result as CommonResult } from "../result/module.f.ts";
+/** Validation result: either the typed value or an error message. */
+export type Result<T extends Type> = CommonResult<Ts<T>, string>;
+declare const objectTypeList: readonly ["null", "array", "record"];
+/** String tags for non-object primitive types. */
+export type NonObjectType = 'undefined' | 'boolean' | 'string' | 'number' | 'bigint' | 'function';
+/** String tags for object types: `'null'`, `'array'`, `'record'`. */
+export type ObjectType = typeof objectTypeList[number];
+/** Union of all base type string tags. */
+export type BaseType = NonObjectType | ObjectType;
+/**
+ * A struct schema: an object whose keys are field names and values are nested `Type`s.
+ * Used to validate plain objects with specific typed fields.
+ */
+export type StructType = object & {
+    readonly [K in string]: Type;
+};
+/** A thunk returning a `NonLazyType`, used for recursive type definitions. */
+export type LazyType = () => NonLazyType;
+/** A `Type` that is not wrapped in a thunk. */
+export type NonLazyType = BaseType | StructType;
+/** Any RTTI type: a base tag string, a struct schema object, or a lazy thunk. */
+export type Type = NonLazyType | LazyType;
+type NonObjectTs<T extends NonObjectType> = T extends 'undefined' ? undefined : T extends 'boolean' ? boolean : T extends 'string' ? string : T extends 'number' ? number : T extends 'bigint' ? bigint : T extends 'function' ? Function : never;
+type ArrayTs = readonly unknown[];
+type RecordTs = object & {
+    readonly [K in string]: unknown;
+};
+type ObjectTs<T extends ObjectType> = T extends 'null' ? null : T extends 'array' ? ArrayTs : T extends 'record' ? RecordTs : never;
+type BaseTs<T extends BaseType> = T extends NonObjectType ? NonObjectTs<T> : T extends ObjectType ? ObjectTs<T> : never;
+type NonLazyTs<T extends NonLazyType> = T extends BaseType ? BaseTs<T> : T extends StructType ? object & {
+    readonly [K in keyof T]: Ts<T[K]>;
+} : never;
+/**
+ * Converts an RTTI `Type` to its corresponding TypeScript type.
+ * @example `Ts<'string'>` → `string`, `Ts<{ x: 'number' }>` → `{ readonly x: number }`
+ */
+export type Ts<T extends Type> = NonLazyTs<ToNonLazy<T>>;
+/** A function that validates an unknown value against type `T`. */
+export type Validate<T extends Type> = (value: unknown) => Result<T>;
+type ToNonLazy<T extends Type> = T extends () => infer R ? R : T;
+/**
+ * Creates a validator function for the given RTTI schema.
+ * @param rtti - A base type tag, struct schema, or lazy thunk.
+ * @returns A function `(value: unknown) => Result<T>`.
+ */
+export declare const validate: <T extends Type>(rtti: T) => Validate<T>;
+export {};

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

@@ -0,0 +1,53 @@
+/**
+ * Runtime type information (RTTI) for validating unknown values against typed schemas.
+ *
+ * A `Type` is either a `BaseType` string tag (e.g. `'string'`, `'number'`, `'record'`),
+ * a `StructType` object mapping field names to nested `Type`s, or a `LazyType` thunk
+ * for recursive definitions. Use {@link validate} to produce a type-safe validator.
+ *
+ * @module
+ */
+import { includes } from "../array/module.f.js";
+import { ok, error } from "../result/module.f.js";
+// object
+const objectTypeList = ['null', 'array', 'record'];
+const isObjectType = includes(objectTypeList);
+const nonObjectValidate = (rtti) => value => typeof value === rtti ? ok(value) : error(rtti);
+const isNull = (v) => v === null;
+const isArray = (v) => v instanceof Array;
+const isRecord = (v) => typeof v === 'object' && !isNull(v) && !isArray(v);
+const wrap = (f) => value => f(value) ? ok(value) : error(`unexpected value: ${value}`);
+const objectSwitch = {
+    null: wrap(isNull),
+    array: wrap(isArray),
+    record: wrap(isRecord),
+};
+const objectValidate = (rtti) => objectSwitch[rtti];
+const baseValidate = (rtti) => isObjectType(rtti) ? objectValidate(rtti) : nonObjectValidate(rtti);
+const recordValidate = (rtti) => value => {
+    if (!isRecord(value)) {
+        return error('record is expected');
+    }
+    for (const [k, t] of Object.entries(rtti)) {
+        const r = validate(t)(value[k]);
+        if (r[0] === 'error') {
+            return r;
+        }
+    }
+    return ok(value);
+};
+const nonLazyValidate = (rtti) => {
+    switch (typeof rtti) {
+        case 'string':
+            return baseValidate(rtti);
+        case 'object':
+            return recordValidate(rtti);
+    }
+};
+const nonLazy = (rtti) => (typeof rtti === 'function' ? rtti() : rtti);
+/**
+ * Creates a validator function for the given RTTI schema.
+ * @param rtti - A base type tag, struct schema, or lazy thunk.
+ * @returns A function `(value: unknown) => Result<T>`.
+ */
+export const validate = (rtti) => nonLazyValidate(nonLazy(rtti));

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

@@ -0,0 +1,54 @@
+declare const _default: {
+    typeof: {
+        [k: string]: (() => void)[];
+    };
+    validate: {
+        undefined: {
+            ok: () => void;
+            error: () => void;
+        };
+        boolean: {
+            ok: () => void;
+            error: () => void;
+        };
+        string: {
+            ok: () => void;
+            error: () => void;
+        };
+        number: {
+            ok: () => void;
+            error: () => void;
+        };
+        bigint: {
+            ok: () => void;
+            error: () => void;
+        };
+        null: {
+            ok: () => void;
+            error: () => void;
+        };
+        array: {
+            ok: () => void;
+            error: () => void;
+        };
+        record: {
+            ok: () => void;
+            error: () => void;
+        };
+        function: {
+            ok: () => void;
+            error: () => void;
+        };
+        lazy: {
+            ok: () => void;
+            error: () => void;
+        };
+        struct: {
+            ok: () => void;
+            missingField: () => void;
+            wrongFieldType: () => void;
+            notObject: () => void;
+        };
+    };
+};
+export default _default;

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

@@ -0,0 +1,89 @@
+import { validate } from "./module.f.js";
+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}`;
+            }
+        })])),
+    validate: {
+        undefined: {
+            ok: () => assertOk(validate('undefined')(undefined)),
+            error: () => assertError(validate('undefined')(null)),
+        },
+        boolean: {
+            ok: () => {
+                assertOk(validate('boolean')(true));
+                assertOk(validate('boolean')(false));
+            },
+            error: () => assertError(validate('boolean')(0)),
+        },
+        string: {
+            ok: () => assertOk(validate('string')('hello')),
+            error: () => assertError(validate('string')(42)),
+        },
+        number: {
+            ok: () => assertOk(validate('number')(3)),
+            error: () => assertError(validate('number')('hello')),
+        },
+        bigint: {
+            ok: () => assertOk(validate('bigint')(4n)),
+            error: () => assertError(validate('bigint')(4)),
+        },
+        null: {
+            ok: () => assertOk(validate('null')(null)),
+            error: () => {
+                assertError(validate('null')(undefined));
+                assertError(validate('null')({}));
+            },
+        },
+        array: {
+            ok: () => {
+                assertOk(validate('array')([]));
+                assertOk(validate('array')([1, 2]));
+            },
+            error: () => {
+                assertError(validate('array')({}));
+                assertError(validate('array')(null));
+            },
+        },
+        record: {
+            ok: () => {
+                assertOk(validate('record')({}));
+                assertOk(validate('record')({ x: 1 }));
+            },
+            error: () => {
+                assertError(validate('record')([]));
+                assertError(validate('record')(null));
+            },
+        },
+        function: {
+            ok: () => assertOk(validate('function')(() => { })),
+            error: () => assertError(validate('function')(null)),
+        },
+        lazy: {
+            ok: () => assertOk(validate(() => 'string')('hello')),
+            error: () => assertError(validate(() => 'string')(42)),
+        },
+        struct: {
+            ok: () => assertOk(validate({ name: 'string', age: 'number' })({ name: 'alice', age: 30 })),
+            missingField: () => assertError(validate({ name: 'string' })({})),
+            wrongFieldType: () => assertError(validate({ name: 'string' })({ name: 42 })),
+            notObject: () => assertError(validate({ name: 'string' })(null)),
+        },
+    }
+};