functionalscript 0.12.7 → 0.12.9

package/io/module.f.d.ts

@@ -1,5 +1,5 @@
 import { type Effect } from '../types/effects/module.f.ts';
-import type { ExecResult, Headers, IoResult, NodeOp } from '../types/effects/node/module.f.ts';
+import type { Headers, NodeOp } from '../types/effects/node/module.f.ts';
 import { type Result } from '../types/result/module.f.ts';
 /**
  * Represents a directory entry (file or directory) in the filesystem
@@ -97,7 +97,11 @@ export type Http = {
     readonly createServer: (_: RequestListener) => Server;
 };
 export type ChildProcess = {
-    readonly exec: (command: string) => Promise<IoResult<ExecResult>>;
+    readonly exec: (command: string, callback: (error: unknown, stdout: string, stderr: string) => void) => {
+        readonly stdin: null | {
+            readonly end: (data?: string) => void;
+        };
+    };
 };
 /**
  * Core IO operations interface providing access to system resources
@@ -128,4 +132,4 @@ export type Run = (f: App) => Promise<never>;
  */
 export declare const run: (io: Io) => Run;
 export type EffectToPromise = <T>(effect: Effect<NodeOp, T>) => Promise<T>;
-export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm } }, fetch, http: { createServer }, childProcess: { exec }, }: Io) => EffectToPromise;
+export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm } }, fetch, http: { createServer }, childProcess, }: Io) => EffectToPromise;

package/io/module.f.js

@@ -35,7 +35,7 @@ const collect = async (v) => {
     }
     return result;
 };
-export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm } }, fetch, http: { createServer }, childProcess: { exec }, }) => {
+export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm } }, fetch, http: { createServer }, childProcess, }) => {
     const result = asyncRun({
         all: async (effects) => await Promise.all(effects.map(result)),
         error: async (message) => error(message),
@@ -53,7 +53,10 @@ export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readF
             .map(v => ({ name: v.name, parentPath: normalize(v.parentPath), isFile: v.isFile() }))),
         writeFile: ([path, data]) => tc(() => writeFile(path, fromVec(data))),
         rm: path => tc(() => rm(path)),
-        exec,
+        exec: ([command, stdin]) => new Promise(resolve => {
+            const child = childProcess.exec(command, (e, stdout, stderr) => resolve(e !== null ? ['error', e] : ok({ stdout, stderr })));
+            child.stdin?.end(stdin);
+        }),
         createServer: async (requestListener) => {
             const erl = requestListener;
             const nodeRl = async (req, res) => {

package/io/module.js

@@ -7,10 +7,10 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import http from 'node:http';
-import { exec } from 'node:child_process';
-import { fromIo, run } from "./module.f.js";
+import childProcess from 'node:child_process';
 import fs from 'node:fs';
 import process from 'node:process';
+import { fromIo, run } from "./module.f.js";
 import { concat } from "../path/module.f.js";
 import { error, ok } from "../types/result/module.f.js";
 const prefix = 'file:///';
@@ -42,9 +42,7 @@ export const io = {
         }
     },
     http,
-    childProcess: {
-        exec: command => new Promise(resolve => exec(command, (e, stdout, stderr) => resolve(e !== null ? error(e) : ok({ stdout, stderr })))),
-    },
+    childProcess,
 };
 export const legacyRun = run(io);
 export const ioRun = (io) => {

package/package.json

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

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

@@ -47,8 +47,9 @@ export type ExecResult = {
     readonly stdout: string;
     readonly stderr: string;
 };
-export type Exec = readonly ['exec', (_: string) => IoResult<ExecResult>];
-export declare const exec: Func<Exec>;
+export type ExecParam = readonly [string, string?];
+export type Exec = readonly ['exec', (_: ExecParam) => IoResult<ExecResult>];
+export declare const exec: RestFunc<Exec>;
 export type Fs = Mkdir | ReadFile | Readdir | WriteFile | Rm | Exec;
 export type Error = ['error', (_: string) => void];
 export declare const error: Func<Error>;

package/types/effects/node/module.f.js

@@ -15,7 +15,7 @@ export const readFile = do_('readFile');
 export const readdir = doRest('readdir');
 export const writeFile = doRest('writeFile');
 export const rm = do_('rm');
-export const exec = do_('exec');
+export const exec = doRest('exec');
 export const error = do_('error');
 export const log = do_('log');
 export const createServer = do_('createServer');

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

@@ -64,4 +64,6 @@ export type Or<T extends readonly Type[]> = () => readonly ['or', ...T];
 export declare const or: <T extends readonly Type[]>(...types: T) => Or<T>;
 /** Constructs a schema that validates a value matching `T` or `undefined`. */
 export declare const option: <T extends Type>(t: T) => Or<readonly [T, undefined]>;
+/** Schema that never matches any value — the empty union, corresponding to TypeScript's `never`. */
+export declare const never: Or<readonly []>;
 export {};

package/types/rtti/module.f.js

@@ -23,3 +23,5 @@ export const record = type1('record');
 export const or = (...types) => () => ['or', ...types];
 /** Constructs a schema that validates a value matching `T` or `undefined`. */
 export const option = (t) => or(t, undefined);
+/** Schema that never matches any value — the empty union, corresponding to TypeScript's `never`. */
+export const never = or();

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

@@ -31,12 +31,36 @@ export type StructTs<T extends Struct> = {
  *
  * @example
  * ```ts
- * type A = Ts<typeof string>           // string
- * type B = Ts<4>                       // 4
- * type C = Ts<Array<typeof number>>    // readonly number[]
+ * 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 ? (I extends readonly ['const', infer C] ? ConstTs<C> : I extends readonly ['boolean'] ? boolean : I extends readonly ['number'] ? number : I extends readonly ['string'] ? string : I extends readonly ['bigint'] ? bigint : I extends readonly ['unknown'] ? DjsUnknown : I extends readonly ['array', infer E extends Type] ? readonly Ts<E>[] : I extends readonly ['record', infer E extends Type] ? {
     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.
+ *
+ * Mirrors the compile-time `Ts<T>` mapped type at runtime.
+ *
+ * **Note:** recursive schemas (e.g. `const list = () => ['array', list] as const`)
+ * will cause infinite recursion. Only acyclic schemas are supported.
+ *
+ * **Note:** the `unknown` schema produces the string `'unknown'` (TypeScript's built-in),
+ * whereas `Ts<>` maps it to `DjsUnknown` from `djs/module.f.ts`.
+ *
+ * @example
+ * ```ts
+ * toTs(boolean)                    // 'boolean'
+ * toTs(array(number))              // 'readonly(number)[]'
+ * toTs(record(string))             // '{readonly[k in 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}'
+ * ```
+ */
+export declare const toTs: (rtti: Type) => string;

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

@@ -1 +1,50 @@
-export {};
+/**
+ * TypeScript type transformers for RTTI schemas.
+ *
+ * Each `*Ts` type maps a schema (or schema fragment) to its corresponding TypeScript type.
+ * The main entry point is `Ts<T>`.
+ *
+ * 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)]));
+/**
+ * Converts an RTTI schema `Type` to its TypeScript type expression as a string.
+ *
+ * Mirrors the compile-time `Ts<T>` mapped type at runtime.
+ *
+ * **Note:** recursive schemas (e.g. `const list = () => ['array', list] as const`)
+ * will cause infinite recursion. Only acyclic schemas are supported.
+ *
+ * **Note:** the `unknown` schema produces the string `'unknown'` (TypeScript's built-in),
+ * whereas `Ts<>` maps it to `DjsUnknown` from `djs/module.f.ts`.
+ *
+ * @example
+ * ```ts
+ * toTs(boolean)                    // 'boolean'
+ * toTs(array(number))              // 'readonly(number)[]'
+ * toTs(record(string))             // '{readonly[k in 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}'
+ * ```
+ */
+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'
+    }
+};

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

@@ -0,0 +1,53 @@
+declare const _default: {
+    tag0: {
+        boolean: () => void;
+        number: () => void;
+        string: () => void;
+        bigint: () => void;
+        unknown: () => void;
+    };
+    tag1: {
+        array: {
+            primitive: () => void;
+            nested: () => void;
+            union: () => void;
+        };
+        record: {
+            primitive: () => void;
+            nested: () => void;
+        };
+    };
+    const: {
+        null: () => void;
+        undefined: () => void;
+        true: () => void;
+        false: () => void;
+        number: () => void;
+        nan: () => void;
+        inf: () => void;
+        negInf: () => void;
+        string: () => void;
+        bigint: () => void;
+        emptyTuple: () => void;
+        tuple: () => void;
+        emptyStruct: () => void;
+        struct: () => void;
+        nestedStruct: () => void;
+        quotedKey: () => void;
+        stringWithQuote: () => void;
+        keyWithQuote: () => void;
+    };
+    constThunk: {
+        primitive: () => void;
+        string: () => void;
+    };
+    or: {
+        empty: () => void;
+        consts: () => void;
+        thunks: () => void;
+        mixed: () => void;
+    };
+    never: () => void;
+    option: () => void;
+};
+export default _default;

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

@@ -0,0 +1,60 @@
+import { toTs } from "./module.f.js";
+import { boolean, number, string, bigint, unknown, array, record, or, option, never } from "../module.f.js";
+const eq = (rtti, expected) => {
+    const result = toTs(rtti);
+    if (result !== expected) {
+        throw `expected ${JSON.stringify(expected)}, got ${JSON.stringify(result)}`;
+    }
+};
+export default {
+    tag0: {
+        boolean: () => eq(boolean, 'boolean'),
+        number: () => eq(number, 'number'),
+        string: () => eq(string, 'string'),
+        bigint: () => eq(bigint, 'bigint'),
+        unknown: () => eq(unknown, 'unknown'),
+    },
+    tag1: {
+        array: {
+            primitive: () => eq(array(number), 'readonly(number)[]'),
+            nested: () => eq(array(array(boolean)), 'readonly(readonly(boolean)[])[]'),
+            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}}'),
+        },
+    },
+    const: {
+        null: () => eq(null, 'null'),
+        undefined: () => eq(undefined, 'undefined'),
+        true: () => eq(true, 'true'),
+        false: () => eq(false, 'false'),
+        number: () => eq(42, '42'),
+        nan: () => eq(NaN, 'number'),
+        inf: () => eq(Infinity, 'number'),
+        negInf: () => eq(-Infinity, 'number'),
+        string: () => eq('hello', '"hello"'),
+        bigint: () => eq(7n, '7n'),
+        emptyTuple: () => eq([], 'readonly[]'),
+        tuple: () => eq([12, true], 'readonly[12,true]'),
+        emptyStruct: () => eq({}, '{}'),
+        struct: () => eq({ a: number, b: string }, '{readonly"a":number,readonly"b":string}'),
+        nestedStruct: () => eq({ x: { y: boolean } }, '{readonly"x":{readonly"y":boolean}}'),
+        quotedKey: () => eq({ 'my-key': number }, '{readonly"my-key":number}'),
+        stringWithQuote: () => eq('say "hi"', '"say \\"hi\\""'),
+        keyWithQuote: () => eq({ 'a"b': number }, '{readonly"a\\"b":number}'),
+    },
+    constThunk: {
+        primitive: () => eq(() => ['const', 42n], '42n'),
+        string: () => eq(() => ['const', 'hi'], '"hi"'),
+    },
+    or: {
+        empty: () => eq(or(), 'never'),
+        consts: () => eq(or(false, 42, 'hello'), 'false|42|"hello"'),
+        thunks: () => eq(or(number, string), 'number|string'),
+        mixed: () => eq(or(42, string), '42|string'),
+    },
+    never: () => eq(never, 'never'),
+    option: () => eq(option(number), 'number|undefined'),
+};

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

@@ -3,7 +3,6 @@ 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";
-import { todo } from "../../../dev/module.f.js";
 /**
  * Builds a validator for `array` or `record` schemas.
  * The inner item validator is instantiated lazily (only when the container is

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

@@ -1,2 +1,8 @@
 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;
+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 +1,19 @@
-export {};
+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}`]);
+export const primitive = (c) => {
+    if (c === null) {
+        return 'null';
+    }
+    switch (typeof c) {
+        case 'bigint': return `${c}n`;
+        case 'string': return JSON.stringify(c);
+        case 'number': return isFinite(c) ? String(c) : 'number';
+        case 'undefined':
+        case 'boolean': return String(c);
+    }
+};
+export const union = (types) => types.length === 0 ? 'never' : types.join('|');