functionalscript 0.12.10 → 0.13.0

package/ci/module.f.js

@@ -69,7 +69,7 @@ const node = (version) => (extra) => basicNode(version)([
 const findTgz = (v) => v === 'windows' ? '(Get-ChildItem *.tgz).FullName' : './*.tgz';
 const playwrightVersion = '1.58.2';
 const playwrightAndVersion = `playwright@${playwrightVersion}`;
-const rustToolchain = '1.94.1';
+const rustToolchain = '1.95.0';
 const toSteps = (m) => {
     const filter = (st) => m.flatMap((mt) => mt.type === st ? [mt.step] : []);
     const aptGet = m.flatMap(v => v.type === 'apt-get' ? [v.package] : []).join(' ');

package/package.json

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

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

@@ -41,9 +41,10 @@ export type Ts<T extends Type> = T extends () => infer I ? (I extends readonly [
     readonly [K in string]: Ts<E>;
 } : I extends readonly ['or', ...infer A extends readonly Type[]] ? Ts<A[number]> : never) : ConstTs<T>;
 /**
- * Converts an RTTI schema `Type` to its TypeScript type expression as a string.
+ * Creates a printer that converts an RTTI schema `Type` to its TypeScript type expression as a string.
  *
  * Mirrors the compile-time `Ts<T>` mapped type at runtime.
+ * Pass `true` to emit mutable (non-`readonly`) types.
  *
  * **Note:** recursive schemas (e.g. `const list = () => ['array', list] as const`)
  * will cause infinite recursion. Only acyclic schemas are supported.
@@ -53,14 +54,19 @@ export type Ts<T extends Type> = T extends () => infer I ? (I extends readonly [
  *
  * @example
  * ```ts
+ * const toTs = printer()
  * toTs(boolean)                    // 'boolean'
  * toTs(array(number))              // 'readonly(number)[]'
- * toTs(record(string))             // '{readonly[k in string]:string}'
+ * toTs(record(string))             // '{readonly[k:string]:string}'
  * toTs(or(string, number))         // 'string|number'
  * toTs(42)                         // '42'
  * toTs('hello')                    // '"hello"'
  * toTs([boolean, number])          // 'readonly[boolean,number]'
- * toTs({ x: string })              // '{readonly "x":string}'
+ * toTs({ x: string })              // '{readonly"x":string}'
+ *
+ * const toTsMut = printer(true)
+ * toTsMut(array(number))           // '(number)[]'
+ * toTsMut(record(string))          // '{[k:string]:string}'
  * ```
  */
-export declare const toTs: (rtti: Type) => string;
+export declare const printer: (mut?: true) => (rtti: Type) => string;

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

@@ -7,15 +7,12 @@
  * The runtime `toTs` function mirrors `Ts<T>` at value level, returning a TypeScript
  * type expression string for a given RTTI schema.
  */
-import { primitive, tuple, struct, array, record, union } from "../../ts/module.f.js";
-/** Serialises a `Const` schema to its TypeScript type expression. */
-const constToTs = (rtti) => typeof rtti !== 'object' || rtti === null ? primitive(rtti) :
-    rtti instanceof Array ? tuple(rtti.map(toTs)) :
-        struct(Object.entries(rtti).map(([k, v]) => [k, toTs(v)]));
+import { primitive, union, printer as tsPrinter } from "../../ts/module.f.js";
 /**
- * Converts an RTTI schema `Type` to its TypeScript type expression as a string.
+ * Creates a printer that converts an RTTI schema `Type` to its TypeScript type expression as a string.
  *
  * Mirrors the compile-time `Ts<T>` mapped type at runtime.
+ * Pass `true` to emit mutable (non-`readonly`) types.
  *
  * **Note:** recursive schemas (e.g. `const list = () => ['array', list] as const`)
  * will cause infinite recursion. Only acyclic schemas are supported.
@@ -25,26 +22,38 @@ const constToTs = (rtti) => typeof rtti !== 'object' || rtti === null ? primitiv
  *
  * @example
  * ```ts
+ * const toTs = printer()
  * toTs(boolean)                    // 'boolean'
  * toTs(array(number))              // 'readonly(number)[]'
- * toTs(record(string))             // '{readonly[k in string]:string}'
+ * toTs(record(string))             // '{readonly[k:string]:string}'
  * toTs(or(string, number))         // 'string|number'
  * toTs(42)                         // '42'
  * toTs('hello')                    // '"hello"'
  * toTs([boolean, number])          // 'readonly[boolean,number]'
- * toTs({ x: string })              // '{readonly "x":string}'
+ * toTs({ x: string })              // '{readonly"x":string}'
+ *
+ * const toTsMut = printer(true)
+ * toTsMut(array(number))           // '(number)[]'
+ * toTsMut(record(string))          // '{[k:string]:string}'
  * ```
  */
-export const toTs = (rtti) => {
-    if (typeof rtti !== 'function') {
-        return constToTs(rtti);
-    }
-    const [tag, ...rest] = rtti();
-    switch (tag) {
-        case 'const': return constToTs(rest[0]);
-        case 'array': return array(toTs(rest[0]));
-        case 'record': return record(toTs(rest[0]));
-        case 'or': return union(rest.map(toTs));
-        default: return tag; // tag0: 'boolean' | 'number' | 'string' | 'bigint' | 'unknown'
-    }
+export const printer = (mut) => {
+    const { tuple, struct, array, record } = tsPrinter(mut);
+    const constToTs = (rtti) => typeof rtti !== 'object' || rtti === null ? primitive(rtti) :
+        rtti instanceof Array ? tuple(rtti.map(toTs)) :
+            struct(Object.entries(rtti).map(([k, v]) => [k, toTs(v)]));
+    const toTs = (rtti) => {
+        if (typeof rtti !== 'function') {
+            return constToTs(rtti);
+        }
+        const [tag, ...rest] = rtti();
+        switch (tag) {
+            case 'const': return constToTs(rest[0]);
+            case 'array': return array(toTs(rest[0]));
+            case 'record': return record(toTs(rest[0]));
+            case 'or': return union(rest.map(toTs));
+            default: return tag; // tag0: 'boolean' | 'number' | 'string' | 'bigint' | 'unknown'
+        }
+    };
+    return toTs;
 };

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

@@ -49,5 +49,12 @@ declare const _default: {
     };
     never: () => void;
     option: () => void;
+    mut: {
+        array: () => void;
+        nestedArray: () => void;
+        record: () => void;
+        tuple: () => void;
+        struct: () => void;
+    };
 };
 export default _default;

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

@@ -1,5 +1,13 @@
-import { toTs } from "./module.f.js";
+import { printer } from "./module.f.js";
 import { boolean, number, string, bigint, unknown, array, record, or, option, never } from "../module.f.js";
+const toTs = printer();
+const toTsMut = printer(true);
+const eqMut = (rtti, expected) => {
+    const result = toTsMut(rtti);
+    if (result !== expected) {
+        throw `expected ${JSON.stringify(expected)}, got ${JSON.stringify(result)}`;
+    }
+};
 const eq = (rtti, expected) => {
     const result = toTs(rtti);
     if (result !== expected) {
@@ -21,8 +29,8 @@ export default {
             union: () => eq(array(or(number, string)), 'readonly(number|string)[]'),
         },
         record: {
-            primitive: () => eq(record(string), '{readonly[k in string]:string}'),
-            nested: () => eq(record(record(number)), '{readonly[k in string]:{readonly[k in string]:number}}'),
+            primitive: () => eq(record(string), '{readonly[k:string]:string}'),
+            nested: () => eq(record(record(number)), '{readonly[k:string]:{readonly[k:string]:number}}'),
         },
     },
     const: {
@@ -57,4 +65,11 @@ export default {
     },
     never: () => eq(never, 'never'),
     option: () => eq(option(number), 'number|undefined'),
+    mut: {
+        array: () => eqMut(array(number), '(number)[]'),
+        nestedArray: () => eqMut(array(array(boolean)), '((boolean)[])[]'),
+        record: () => eqMut(record(string), '{[k:string]:string}'),
+        tuple: () => eqMut([12, true], '[12,true]'),
+        struct: () => eqMut({ a: number, b: string }, '{"a":number,"b":string}'),
+    },
 };

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

@@ -1,8 +1,17 @@
 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;
-export declare const tuple: (types: readonly string[]) => string;
-export declare const struct: (fields: readonly (readonly [string, string])[]) => string;
-export declare const array: (type: string) => string;
-export declare const record: (type: string) => string;
+/** Functions for emitting TypeScript type expression strings. */
+export type Printer = {
+    /** Emits a tuple type: `readonly[A, B]` or `[A, B]` when mutable. */
+    readonly tuple: (types: readonly string[]) => string;
+    /** Emits an object type with named fields: `{readonly"k":T}` or `{"k":T}` when mutable. */
+    readonly struct: (fields: readonly (readonly [string, string])[]) => string;
+    /** Emits an array type: `readonly(T)[]` or `(T)[]` when mutable. */
+    readonly array: (type: string) => string;
+    /** Emits an index-signature record type: `{readonly[k:string]:T}` or `{[k:string]:T}` when mutable. */
+    readonly record: (type: string) => string;
+};
+/** Creates a `Printer`. Pass `true` to emit mutable (non-`readonly`) types. */
+export declare const printer: (mut?: true) => Printer;
 export declare const primitive: (c: bigint | string | undefined | boolean | number | null) => string;
 export declare const union: (types: readonly string[]) => string;

package/types/ts/module.f.js

@@ -1,9 +1,15 @@
 const complex = (open, close) => (i) => `${open}${i.join(',')}${close}`;
-export const tuple = complex('readonly[', ']');
 const structX = complex('{', '}');
-export const struct = (fields) => structX(fields.map(([k, v]) => `readonly${JSON.stringify(k)}:${v}`));
-export const array = (type) => `readonly(${type})[]`;
-export const record = (type) => structX([`readonly[k in string]:${type}`]);
+/** Creates a `Printer`. Pass `true` to emit mutable (non-`readonly`) types. */
+export const printer = (mut) => {
+    const ro = mut ? '' : 'readonly';
+    return {
+        tuple: (mut ? complex('[', ']') : complex('readonly[', ']')),
+        struct: (fields) => structX(fields.map(([k, v]) => `${ro}${JSON.stringify(k)}:${v}`)),
+        array: (type) => `${ro}(${type})[]`,
+        record: (type) => structX([`${ro}[k:string]:${type}`]),
+    };
+};
 export const primitive = (c) => {
     if (c === null) {
         return 'null';