functionalscript 0.16.1 → 0.18.0

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

@@ -1,71 +1,60 @@
 import {} from "../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";
+import {} from "../../object/module.f.js";
 import { find, map as listMap } from "../../list/module.f.js";
-import { constPrimitiveValidate, prependPath, primitive0Validate, verror, visit, } from "../common/module.f.js";
+import { constPrimitiveValidate, isArray, isObject, prependPath, primitive0Validate, verror, visit, } from "../common/module.f.js";
 export {} from "../common/module.f.js";
-const indexedFirstError = (results) => {
-    // TODO: findIndex breaks type inference,
-    //       we should replace it with something else.
-    const i = results.findIndex(r => r[0] === 'error');
-    return i < 0 ? null : [i, results[i]];
-};
+const { entries } = Object;
 const keyedFirstError = (results) => {
     const e = results.find(([, r]) => r[0] === 'error');
     return e === undefined ? null : [e[0], e[1]];
 };
-const arrayParse = (item) => value => {
-    if (!commonIsArray(value)) {
-        return verror('unexpected value');
-    }
-    if (value.length === 0) {
-        return ok([]);
-    }
-    // Note: we shouldn't instantiate `itemParse` until we know the array is non-empty.
-    //       Otherwise, we can get infinite recursion on empty arrays for recursive schemas.
-    const itemParse = parse(item);
-    const results = value.map(itemParse);
-    const err = indexedFirstError(results);
-    return (err === null
-        ? ok(results.map(r => r[1]))
-        : prependPath(String(err[0]), err[1]));
-};
-const recordParse = (item) => value => {
-    if (!commonIsObject(value)) {
+const arrayRebuild = entries => entries.map(([, v]) => v);
+const recordRebuild = entries => Object.fromEntries(entries);
+/** Drops the `'ok'` tag from each result, yielding the rebuild's `[key, value]` entries. */
+const okEntries = (results) => results.map(([k, r]) => [k, r[1]]);
+/**
+ * Builds a parser for `array` or `record` schemas. Mirrors `validate`'s
+ * `containerValidate`, but rebuilds a fresh container from each item's parsed
+ * result instead of returning the value unchanged. The inner item parser is
+ * instantiated lazily (only when the container is non-empty) so recursive
+ * schemas don't recurse forever on empty containers.
+ */
+const containerParse = (isContainer, rebuild) => (item) => value => {
+    if (!isContainer(value)) {
         return verror('unexpected value');
     }
-    const entries = Object.entries(value);
-    if (entries.length === 0) {
-        return ok({});
+    const e = entries(value);
+    if (e.length === 0) {
+        return ok(rebuild([]));
     }
     const itemParse = parse(item);
-    const results = entries.map(([k, v]) => [k, itemParse(v)]);
+    const results = e.map(([k, v]) => [k, itemParse(v)]);
     const err = keyedFirstError(results);
     return (err === null
-        ? ok(Object.fromEntries(results.map(([k, r]) => [k, r[1]])))
+        ? ok(rebuild(okEntries(results)))
         : prependPath(err[0], err[1]));
 };
-const tupleParse = (rtti) => value => {
-    if (!commonIsArray(value)) {
-        return verror('unexpected value');
-    }
-    const results = rtti.map((t, i) => parse(t)(value[i]));
-    const err = indexedFirstError(results);
-    return (err === null
-        ? ok(results.map(r => r[1]))
-        : prependPath(String(err[0]), err[1]));
-};
-const structParse = (rtti) => value => {
-    if (!commonIsObject(value)) {
+const arrayParse = containerParse(isArray, arrayRebuild);
+const recordParse = containerParse(isObject, recordRebuild);
+/**
+ * Builds a parser for `Tuple` or `Struct` const schemas. Mirrors `validate`'s
+ * `constContainerValidate`: it iterates the schema's entries (so extra tuple
+ * elements and undeclared struct keys are dropped) and rebuilds the result
+ * from each parsed item.
+ */
+const constContainerParse = (isContainer, getItem, rebuild) => (rtti) => value => {
+    if (!isContainer(value)) {
         return verror('unexpected value');
     }
-    const results = Object.entries(rtti).map(([k, t]) => [k, parse(t)(value[k])]);
+    const results = entries(rtti).map(([k, t]) => [k, parse(t)(getItem(value, k))]);
     const err = keyedFirstError(results);
     return (err === null
-        ? ok(Object.fromEntries(results.map(([k, r]) => [k, r[1]])))
+        ? ok(rebuild(okEntries(results)))
         : prependPath(err[0], err[1]));
 };
+const tupleParse = constContainerParse(isArray, (value, k) => value[Number(k)], arrayRebuild);
+const structParse = constContainerParse(isObject, (value, k) => value[k], recordRebuild);
 const findFirst = find(verror('no match'))((k) => k[0] === 'ok');
 const orParse = (rtti) => value => findFirst(listMap(t => parse(t)(value))(rtti));
 /**

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

@@ -1,26 +1,26 @@
 import {} from "../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";
-import { constPrimitiveValidate, prependPath, primitive0Validate, verror, visit, } from "../common/module.f.js";
+import {} from "../../object/module.f.js";
+import { constPrimitiveValidate, isArray, isObject, prependPath, primitive0Validate, verror, visit, } from "../common/module.f.js";
 export { constPrimitiveValidate, prependPath, primitive0Validate, verror, } from "../common/module.f.js";
+const { entries } = Object;
 /**
  * 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, getEntries) => (item) => value => {
+const containerValidate = (isContainer) => (item) => value => {
     if (!isContainer(value)) {
         return verror('unexpected value');
     }
-    const entries = getEntries(value);
-    if (entries.length === 0) {
+    const e = entries(value);
+    if (e.length === 0) {
         return ok(value);
     }
     // Note: we shouldn't instantiate `itemValidate` until we make sure `entries` is not empty.
     //       Otherwise, we can get infinite recursion on empty arrays and objects
     const itemValidate = validate(item);
-    for (const [k, v] of entries) {
+    for (const [k, v] of e) {
         const r = itemValidate(v);
         if (r[0] === 'error') {
             return prependPath(k, r);
@@ -28,11 +28,8 @@ const containerValidate = (isContainer, getEntries) => (item) => value => {
     }
     return ok(value);
 };
-const isArray = value => commonIsArray(value);
-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);
+const arrayValidate = containerValidate(isArray);
+const recordValidate = containerValidate(isObject);
 /**
  * Builds a validator for `Tuple` or `Struct` const schemas.
  * Iterates over the schema's entries and validates each corresponding

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

@@ -3,12 +3,11 @@
  *
  * @module
  */
-import type { Sign } from '../function/compare/module.f.ts';
+import { type Sign, type Cmp } from '../function/compare/module.f.ts';
 import { type List } from '../list/module.f.ts';
 import type { Nullable } from '../nullable/module.f.ts';
 export type SortedList<T> = List<T>;
 type SortedArray<T> = readonly T[];
-type Cmp<T> = (a: T) => (b: T) => Sign;
 export type ReduceOp<T, S> = (state: S) => (a: T) => (b: T) => readonly [Nullable<T>, Sign, S];
 export type TailReduce<T, S> = (state: S) => (tail: List<T>) => List<T>;
 type MergeReduce<T, S> = {

package/fs/types/sorted_list/module.f.js

@@ -1,3 +1,9 @@
+/**
+ * Sorted immutable list helpers and merge operations.
+ *
+ * @module
+ */
+import { bsearch } from "../function/compare/module.f.js";
 import { next } from "../list/module.f.js";
 import { identity } from "../function/module.f.js";
 export const genericMerge = ({ reduceOp, tailReduce }) => {
@@ -29,25 +35,6 @@ const cmpReduce = (cmp) => () => a => b => {
 const mergeTail = () => identity;
 export const find = (cmp) => (value) => (array) => {
     const cmpValue = cmp(value);
-    let b = 0;
-    let e = array.length - 1;
-    while (true) {
-        const d = e - b;
-        if (d < 0)
-            return null;
-        const mid = b + (d >> 1);
-        switch (cmpValue(array[mid])) {
-            case -1: {
-                e = mid - 1;
-                break;
-            }
-            case 0: {
-                return value;
-            }
-            case 1: {
-                b = mid + 1;
-                break;
-            }
-        }
-    }
+    const pos = bsearch(array.length)(mid => cmpValue(array[mid]));
+    return pos < array.length && cmpValue(array[pos]) === 0 ? value : null;
 };

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

@@ -26,10 +26,8 @@
  * has(cmp)(2)(setA) // false
  * ```
  */
-import type { Sign } from '../function/compare/module.f.ts';
+import type { Cmp } from '../function/compare/module.f.ts';
 export type SortedSet<T> = readonly T[];
-type Cmp<T> = (a: T) => (b: T) => Sign;
 export declare const union: <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>;
 export declare const intersect: <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>;
 export declare const has: <T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean;
-export {};

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

@@ -1,3 +1,10 @@
+/**
+ * TypeScript source-emitter helpers: the `Equal`/`Assert` compile-time
+ * predicates and a `Printer` that renders tuples, structs, arrays, records,
+ * primitive literals, and unions as TypeScript type expressions.
+ *
+ * @module
+ */
 export type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
 export type Assert<T extends true> = T;
 /** Functions for emitting TypeScript type expression strings. */

package/fs/types/ts/test.f.d.ts

@@ -0,0 +1,18 @@
+export declare const primitiveNull: () => void;
+export declare const primitiveBigint: () => void;
+export declare const primitiveString: () => void;
+export declare const primitiveNumberFinite: () => void;
+export declare const primitiveNumberInfinite: () => void;
+export declare const primitiveUndefined: () => void;
+export declare const primitiveBoolean: () => void;
+export declare const unionEmpty: () => void;
+export declare const unionSingle: () => void;
+export declare const unionMulti: () => void;
+export declare const printerReadonlyTuple: () => void;
+export declare const printerReadonlyStruct: () => void;
+export declare const printerReadonlyArray: () => void;
+export declare const printerReadonlyRecord: () => void;
+export declare const printerMutableTuple: () => void;
+export declare const printerMutableStruct: () => void;
+export declare const printerMutableArray: () => void;
+export declare const printerMutableRecord: () => void;

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

@@ -0,0 +1,111 @@
+import { printer, primitive, union } from "./module.f.js";
+const ro = printer();
+const mut = printer(true);
+export const primitiveNull = () => {
+    const r = primitive(null);
+    if (r !== 'null') {
+        throw r;
+    }
+};
+export const primitiveBigint = () => {
+    const r = primitive(42n);
+    if (r !== '42n') {
+        throw r;
+    }
+};
+export const primitiveString = () => {
+    const r = primitive('hello');
+    if (r !== '"hello"') {
+        throw r;
+    }
+};
+export const primitiveNumberFinite = () => {
+    const r = primitive(3.14);
+    if (r !== '3.14') {
+        throw r;
+    }
+};
+export const primitiveNumberInfinite = () => {
+    const r = primitive(Infinity);
+    if (r !== 'number') {
+        throw r;
+    }
+};
+export const primitiveUndefined = () => {
+    const r = primitive(undefined);
+    if (r !== 'undefined') {
+        throw r;
+    }
+};
+export const primitiveBoolean = () => {
+    const r = primitive(true);
+    if (r !== 'true') {
+        throw r;
+    }
+};
+export const unionEmpty = () => {
+    const r = union([]);
+    if (r !== 'never') {
+        throw r;
+    }
+};
+export const unionSingle = () => {
+    const r = union(['string']);
+    if (r !== 'string') {
+        throw r;
+    }
+};
+export const unionMulti = () => {
+    const r = union(['string', 'number']);
+    if (r !== 'string|number') {
+        throw r;
+    }
+};
+export const printerReadonlyTuple = () => {
+    const r = ro.tuple(['string', 'number']);
+    if (r !== 'readonly[string,number]') {
+        throw r;
+    }
+};
+export const printerReadonlyStruct = () => {
+    const r = ro.struct([['x', 'number'], ['y', 'string']]);
+    if (r !== '{readonly"x":number,readonly"y":string}') {
+        throw r;
+    }
+};
+export const printerReadonlyArray = () => {
+    const r = ro.array('string');
+    if (r !== 'readonly(string)[]') {
+        throw r;
+    }
+};
+export const printerReadonlyRecord = () => {
+    const r = ro.record('number');
+    if (r !== '{readonly[k:string]:number}') {
+        throw r;
+    }
+};
+export const printerMutableTuple = () => {
+    const r = mut.tuple(['string', 'number']);
+    if (r !== '[string,number]') {
+        throw r;
+    }
+};
+export const printerMutableStruct = () => {
+    const r = mut.struct([['x', 'number']]);
+    if (r !== '{"x":number}') {
+        throw r;
+    }
+};
+export const printerMutableArray = () => {
+    const r = mut.array('string');
+    if (r !== '(string)[]') {
+        throw r;
+    }
+};
+export const printerMutableRecord = () => {
+    const r = mut.record('number');
+    if (r !== '{[k:string]:number}') {
+        throw r;
+    }
+};

package/fs/types/uint8array/module.f.js

@@ -1,5 +1,11 @@
 /**
- * Conversions between Uint8Array values and bit vectors.
+ * Conversions between `Uint8Array` values and bit vectors.
+ *
+ * @deprecated FunctionalScript represents byte data as `bigint`-based bit
+ * vectors (`Vec` from `fs/types/bit_vec`). Use `utf8`/`utf8ToString` from
+ * `fs/text` for string encoding, and the `bit_vec` module directly for raw
+ * byte manipulation. `Uint8Array` interop belongs at Node.js boundaries only
+ * (e.g. `fromVec`/`toVec` when reading or writing files).
  *
  * @module
  */

package/fs/types/uint8array/test.f.d.ts

@@ -8,5 +8,6 @@ declare const _default: {
     decodeUtf8Ascii: () => void;
     decodeUtf8Multibyte: () => void;
     utf8RoundTrip: () => void;
+    listToVec: () => void;
 };
 export default _default;

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

@@ -1,5 +1,5 @@
 import { vec } from "../bit_vec/module.f.js";
-import { toVec, fromVec, decodeUtf8, encodeUtf8 } from "./module.f.js";
+import { toVec, fromVec, listToVec, decodeUtf8, encodeUtf8 } from "./module.f.js";
 import { strictEqual } from "../function/operator/module.f.js";
 import { equal, fromArrayLike } from "../list/module.f.js";
 const assertEq = (a, b) => {
@@ -54,5 +54,9 @@ export default {
         const input = 'FunctionalScript 🐝';
         const output = decodeUtf8(encodeUtf8(input));
         assertEq(output, input);
+    },
+    listToVec: () => {
+        const result = listToVec([Uint8Array.from([1, 2]), Uint8Array.from([3])]);
+        assertArrayEq(fromVec(result), Uint8Array.from([1, 2, 3]));
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.16.1",
+  "version": "0.18.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -15,7 +15,8 @@
     "start": "node ./fs/fjs/module.ts",
     "ci-update": "node ./fs/fjs/module.ts r ./fs/ci/module.f.ts",
     "update": "npm install && npm run index && npm run ci-update",
-    "website": "node --experimental-strip-types ./fs/fjs/module.ts r ./fs/website/module.f.ts"
+    "index-html": "node --experimental-strip-types ./fs/fjs/module.ts r ./fs/website/module.f.ts",
+    "website": "npm run prepack &&npm run index-html"
   },
   "engines": {
     "node": ">=22"

package/fs/io/virtual/module.f.d.ts

@@ -1,8 +0,0 @@
-/**
- * Virtual I/O adapter implementations for deterministic testing.
- *
- * @module
- */
-import type { Io } from '../module.f.ts';
-import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
-export declare const createVirtualIo: (files: OrderedMap<Uint8Array>) => Io;

package/fs/io/virtual/module.f.js

@@ -1,43 +0,0 @@
-import { at } from "../../types/ordered_map/module.f.js";
-import { todo } from "../../dev/module.f.js";
-export const createVirtualIo = (files) => ({
-    console: {
-        log: (..._d) => { },
-        error: (..._d) => { }
-    },
-    fs: {
-        writeSync: (_fd, _s) => { },
-        writeFileSync: (_file, _data) => { },
-        readFileSync: (path) => { return at(path)(files); },
-        promises: {
-            readdir: (_path) => Promise.resolve([]),
-            readFile: (_path) => Promise.resolve(new Uint8Array()),
-            writeFile: (_path, _data) => Promise.resolve(),
-            rm: (_path, _options) => Promise.resolve(),
-            mkdir: (_path, _options) => Promise.resolve(undefined),
-            copyFile: (_src, _dest) => Promise.resolve(),
-            access: (_path) => Promise.resolve(),
-        }
-    },
-    process: {
-        argv: [],
-        env: {},
-        exit: n => { throw n; },
-        cwd: () => '',
-        stdout: { fd: 1, isTTY: false },
-        stderr: { fd: 2, isTTY: false },
-    },
-    asyncImport: () => Promise.reject(),
-    performance: {
-        now: () => 0,
-    },
-    fetch: () => Promise.reject(),
-    tryCatch: f => ['ok', f()],
-    asyncTryCatch: async (f) => ['ok', await f()],
-    http: {
-        createServer: todo
-    },
-    childProcess: {
-        exec: todo,
-    },
-});