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

functionalscript 0.11.9 → 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 (10) hide show

package/html/module.f.js +5 -2
package/package.json +1 -1
package/types/array/module.f.d.ts +1 -0
package/types/array/module.f.js +1 -0
package/types/bit_vec/module.f.d.ts +2 -1
package/types/bit_vec/module.f.js +22 -22
package/types/rtti/module.f.d.ts +48 -0
package/types/rtti/module.f.js +53 -0
package/types/rtti/test.f.d.ts +54 -0
package/types/rtti/test.f.js +89 -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/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.11.9",
+  "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/bit_vec/module.f.d.ts CHANGED Viewed

@@ -162,6 +162,7 @@ export type BitOrder = {
      */
     readonly cmp: (a: Vec) => (b: Vec) => Sign;
     readonly unpackSplit: (len: bigint) => (u: Unpacked) => readonly [bigint, bigint];
+    readonly unpackConcat: (a: Unpacked) => (b: Unpacked) => Unpacked;
 };
 /**
  * Implements operations for handling vectors in a least-significant-bit (LSb) first order.
@@ -186,7 +187,7 @@ export declare const msb: BitOrder;
  * @param list The list of unsigned 8-bit integers to be converted.
  * @returns The resulting vector based on the provided bit order.
  */
-export declare const u8ListToVec: ({ concat }: BitOrder) => (list: List<number>) => Vec;
+export declare const u8ListToVec: ({ unpackConcat }: BitOrder) => (list: List<number>) => Vec;
 /**
  * Converts a bit vector to a list of unsigned 8-bit integers based on the provided bit order.
  *

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

@@ -107,7 +107,7 @@ const op = (norm) => (op) => ap => bp => {
     const { a, b } = norm(au)(bu)(len);
     return vec(len)(op(a)(b));
 };
-const bo = ({ front, removeFront, concat, norm, uintCmp, unpackSplit }) => {
+const bo = ({ front, removeFront, norm, uintCmp, unpackSplit, unpackConcatUint }) => {
     const unpackPopFront = (len) => {
         const m = mask(len);
         const us = unpackSplit(len);
@@ -116,10 +116,17 @@ const bo = ({ front, removeFront, concat, norm, uintCmp, unpackSplit }) => {
             return [uint & m, { length: v.length - len, uint: rest }];
         };
     };
+    const unpackConcat = (a) => (b) => ({
+        length: a.length + b.length, uint: unpackConcatUint(a)(b)
+    });
     return {
         front,
         removeFront,
-        concat,
+        concat: a => b => {
+            const au = unpack(a);
+            const bu = unpack(b);
+            return pack(unpackConcat(au)(bu));
+        },
         xor: op(norm)(xor),
         unpackPopFront,
         popFront: len => {
@@ -140,8 +147,10 @@ const bo = ({ front, removeFront, concat, norm, uintCmp, unpackSplit }) => {
             return c === 0 ? cmp(al)(bl) : c;
         },
         unpackSplit,
+        unpackConcat,
     };
 };
+const lsbUnpackConcatUint = ({ uint: a, length }) => ({ uint: b }) => (b << length) | a;
 /**
  * Implements operations for handling vectors in a least-significant-bit (LSb) first order.
  *
@@ -158,17 +167,13 @@ export const lsb = bo({
         const { length, uint } = unpack(v);
         return vec(length - len)(uint >> len);
     },
-    concat: (a) => (b) => {
-        const { length: al, uint: au } = unpack(a);
-        const { length: bl, uint: bu } = unpack(b);
-        return vec(al + bl)((bu << al) | au);
-    },
     norm: ({ uint: a }) => ({ uint: b }) => () => ({ a, b }),
     uintCmp: a => b => {
         const diff = a ^ b;
         return diff === 0n ? 0 : (a & (diff & -diff)) === 0n ? -1 : 1;
     },
-    unpackSplit: len => ({ uint }) => [uint, uint >> len]
+    unpackSplit: len => ({ uint }) => [uint, uint >> len],
+    unpackConcatUint: lsbUnpackConcatUint
 });
 /**
  * Implements operations for handling vectors in a most-significant-bit (MSb) first order.
@@ -189,11 +194,12 @@ export const msb = bo({
         const { length, uint } = unpack(v);
         return vec(length - len)(uint);
     },
-    concat: flip(lsb.concat),
     norm: ({ length: al, uint: a }) => ({ length: bl, uint: b }) => len => ({ a: a << (len - al), b: b << (len - bl) }),
     uintCmp: cmp,
-    unpackSplit: len => ({ length, uint }) => [uint >> (length - len), uint]
+    unpackSplit: len => ({ length, uint }) => [uint >> (length - len), uint],
+    unpackConcatUint: flip(lsbUnpackConcatUint),
 });
+const unpackEmpty = { length: 0n, uint: 0n };
 /**
  * Converts a list of unsigned 8-bit integers to a bit vector using the provided bit order.
  *
@@ -201,16 +207,10 @@ export const msb = bo({
  * @param list The list of unsigned 8-bit integers to be converted.
  * @returns The resulting vector based on the provided bit order.
  */
-export const u8ListToVec = ({ concat }) => (list) => {
-    // much faster than: `fold(appendU8(bo))(empty)(list)`
-    // where `appendU8` is defined as
-    // ```
-    // const appendU8 = ({ concat }: BitOrder) => (u8: number) => (a: Vec) =>
-    //    concat(a)(vec8(BigInt(u8)))
-    // ```
+export const u8ListToVec = ({ unpackConcat }) => (list) => {
     let result = [];
     for (const b of iterable(list)) {
-        let v = vec8(BigInt(b));
+        let v = { length: 8n, uint: BigInt(b) };
         let i = 0;
         while (true) {
             if (result.length <= i) {
@@ -218,16 +218,16 @@ export const u8ListToVec = ({ concat }) => (list) => {
                 break;
             }
             const old = result[i];
-            if (old === empty) {
+            if (old.length === 0n) {
                 result = result.toSpliced(i, 1, v);
                 break;
             }
-            result = result.toSpliced(i, 1, empty);
-            v = concat(old)(v);
+            result = result.toSpliced(i, 1, unpackEmpty);
+            v = unpackConcat(old)(v);
             i++;
         }
     }
-    return result.reduce((p, c) => concat(c)(p), empty);
+    return pack(result.reduce((p, c) => unpackConcat(c)(p), unpackEmpty));
 };
 /**
  * Converts a bit vector to a list of unsigned 8-bit integers based on the provided bit order.

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)),
+        },
+    }
+};