functionalscript 0.11.1 → 0.11.3

package/io/module.f.d.ts

@@ -1,5 +1,5 @@
 import { type Effect } from '../types/effects/module.f.ts';
-import type { NodeOp } from '../types/effects/node/module.f.ts';
+import type { NodeOp, RequestListener } 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
@@ -79,6 +79,12 @@ export type Process = {
     readonly stderr: Writable;
 };
 export type TryCatch = <T>(f: () => T) => Result<T, unknown>;
+export type Server = {
+    readonly listen: (port: number) => void;
+};
+export type Https = {
+    readonly createServer: (_: RequestListener) => Server;
+};
 /**
  * Core IO operations interface providing access to system resources
  */
@@ -91,6 +97,7 @@ export type Io = {
     readonly fetch: (url: string) => Promise<Response>;
     readonly tryCatch: TryCatch;
     readonly asyncTryCatch: <T>(f: () => Promise<T>) => Promise<Result<T, unknown>>;
+    readonly https: Https;
 };
 /**
  * The environment variables.
@@ -106,4 +113,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 } }, fetch, }: Io) => EffectToPromise;
+export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, fetch, https: { createServer }, }: Io) => EffectToPromise;

package/io/module.f.js

@@ -1,7 +1,8 @@
 import { todo } from "../dev/module.f.js";
 import { normalize } from "../path/module.f.js";
-import { pure } from "../types/effects/module.f.js";
+import {} from "../types/effects/module.f.js";
 import { asyncRun } from "../types/effects/module.js";
+import { asBase, asNominal } from "../types/nominal/module.f.js";
 import { error, ok } from "../types/result/module.f.js";
 import { fromVec, toVec } from "../types/uint8array/module.f.js";
 /**
@@ -28,9 +29,9 @@ const tc = async (f) => {
         return error(e);
     }
 };
-export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, fetch, }) => {
+export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, fetch, https: { createServer }, }) => {
     const result = asyncRun({
-        all: async (effects) => await Promise.all(effects.map(v => result(v))),
+        all: async (effects) => await Promise.all(effects.map(result)),
         error: async (message) => error(message),
         log: async (message) => log(message),
         fetch: async (url) => tc(async () => {
@@ -45,6 +46,14 @@ export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readF
         readdir: ([path, r]) => tc(async () => (await readdir(path, { ...r, withFileTypes: true }))
             .map(v => ({ name: v.name, parentPath: normalize(v.parentPath), isFile: v.isFile() }))),
         writeFile: ([path, data]) => tc(() => writeFile(path, fromVec(data))),
+        createServer: async (requestListener) => {
+            const server = asNominal(createServer(requestListener));
+            return server;
+        },
+        listen: async ([server, port]) => {
+            const s = asBase(server);
+            s.listen(port);
+        },
     });
     return result;
 };

package/io/module.js

@@ -6,6 +6,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
+import https from 'node:https';
 import { fromIo, run } from "./module.f.js";
 import fs from 'node:fs';
 import process from "node:process";
@@ -39,6 +40,7 @@ export const io = {
             return error(e);
         }
     },
+    https
 };
 export const legacyRun = run(io);
 export const ioRun = (io) => {

package/io/virtual/module.f.js

@@ -1,4 +1,5 @@
 import { at } from "../../types/ordered_map/module.f.js";
+import { todo } from "../../dev/module.f.js";
 export const createVirtualIo = (files) => ({
     console: {
         log: (..._d) => { },
@@ -33,4 +34,7 @@ export const createVirtualIo = (files) => ({
     fetch: () => Promise.reject(),
     tryCatch: f => ['ok', f()],
     asyncTryCatch: async (f) => ['ok', await f()],
+    https: {
+        createServer: todo
+    }
 });

package/json/parser/module.f.d.ts

@@ -7,4 +7,10 @@ import { type Result } from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 import { type JsonToken } from '../tokenizer/module.f.ts';
 import { type Unknown } from '../module.f.ts';
+/**
+ * Parses a list of JSON tokens into a JSON-compatible value.
+ *
+ * Returns `ok` with the parsed value on success, or `error` with a message
+ * when the token sequence is invalid or incomplete.
+ */
 export declare const parse: (tokenList: List<JsonToken>) => Result<Unknown, string>;

package/json/parser/module.f.js

@@ -156,6 +156,12 @@ const foldOp = token => state => {
         case '{,': return parseObjectCommaOp(token)(state);
     }
 };
+/**
+ * Parses a list of JSON tokens into a JSON-compatible value.
+ *
+ * Returns `ok` with the parsed value on success, or `error` with a message
+ * when the token sequence is invalid or incomplete.
+ */
 export const parse = tokenList => {
     const state = fold(foldOp)({ status: '', top: null, stack: null })(tokenList);
     switch (state.status) {

package/json/serializer/module.f.d.ts

@@ -4,9 +4,21 @@
  * @module
  */
 import { type List } from '../../types/list/module.f.ts';
+/**
+ * Serializes a string as a JSON string literal.
+ */
 export declare const stringSerialize: (_: string) => List<string>;
+/**
+ * Serializes a number as a JSON number literal.
+ */
 export declare const numberSerialize: (_: number) => List<string>;
+/**
+ * Shared serialized representation for `null`.
+ */
 export declare const nullSerialize: string[];
 export declare const boolSerialize: (_: boolean) => List<string>;
 export declare const objectWrap: (input: List<List<string>>) => List<string>;
+/**
+ * Wraps serialized entries into a JSON array.
+ */
 export declare const arrayWrap: (input: List<List<string>>) => List<string>;

package/json/serializer/module.f.js

@@ -7,8 +7,17 @@ import { flat, reduce, empty } from "../../types/list/module.f.js";
 import {} from "../../types/object/module.f.js";
 import {} from "../../types/function/operator/module.f.js";
 const jsonStringify = JSON.stringify;
+/**
+ * Serializes a string as a JSON string literal.
+ */
 export const stringSerialize = input => [jsonStringify(input)];
+/**
+ * Serializes a number as a JSON number literal.
+ */
 export const numberSerialize = input => [jsonStringify(input)];
+/**
+ * Shared serialized representation for `null`.
+ */
 export const nullSerialize = ['null'];
 const trueSerialize = ['true'];
 const falseSerialize = ['false'];
@@ -22,4 +31,7 @@ const wrap = open => close => {
     return input => flat([seqOpen, join(input), seqClose]);
 };
 export const objectWrap = wrap('{')('}');
+/**
+ * Wraps serialized entries into a JSON array.
+ */
 export const arrayWrap = wrap('[')(']');

package/json/tokenizer/module.f.d.ts

@@ -5,4 +5,11 @@ export type JsonToken = {
 } | {
     readonly kind: '{' | '}' | ':' | ',' | '[' | ']';
 } | StringToken | NumberToken | ErrorToken | EofToken;
+/**
+ * Converts a stream of UTF-8 bytes into JSON tokens.
+ *
+ * The tokenizer accepts only JSON-compatible JavaScript tokens, ignores
+ * whitespace/newline tokens, and reports invalid token sequences as
+ * `{ kind: 'error' }` tokens.
+ */
 export declare const tokenize: (input: List<number>) => List<JsonToken>;

package/json/tokenizer/module.f.js

@@ -50,6 +50,13 @@ const scanToken = state => input => {
         default: return parseDefaultState(input);
     }
 };
+/**
+ * Converts a stream of UTF-8 bytes into JSON tokens.
+ *
+ * The tokenizer accepts only JSON-compatible JavaScript tokens, ignores
+ * whitespace/newline tokens, and reports invalid token sequences as
+ * `{ kind: 'error' }` tokens.
+ */
 export const tokenize = (input) => {
     const jsTokens = jsTokenize(input)('');
     return flat(stateScan(scanToken)({ kind: 'def' })(concat(jsTokens)([null])));

package/package.json

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

package/path/module.f.d.ts

@@ -4,6 +4,19 @@
  * @module
  */
 import type { Reduce, Unary } from "../types/function/operator/module.f.ts";
+/**
+ * Splits a path into normalized segments.
+ *
+ * Empty (`""`) and current-directory (`"."`) segments are removed, parent-directory
+ * (`".."`) segments collapse the previous segment when possible, and Windows
+ * separators are converted to POSIX separators.
+ */
 export declare const parse: (path: string) => readonly string[];
+/**
+ * Normalizes a path string by parsing and rejoining it with POSIX separators.
+ */
 export declare const normalize: Unary<string, string>;
+/**
+ * Concatenates two path fragments and returns a normalized path.
+ */
 export declare const concat: Reduce<string>;

package/path/module.f.js

@@ -21,14 +21,27 @@ const foldNormalizeOp = input => state => {
         }
     }
 };
+/**
+ * Splits a path into normalized segments.
+ *
+ * Empty (`""`) and current-directory (`"."`) segments are removed, parent-directory
+ * (`".."`) segments collapse the previous segment when possible, and Windows
+ * separators are converted to POSIX separators.
+ */
 export const parse = (path) => {
     const split = path.replaceAll('\\', '/').split('/');
     return toArray(fold(foldNormalizeOp)([])(split));
 };
+/**
+ * Normalizes a path string by parsing and rejoining it with POSIX separators.
+ */
 export const normalize = path => {
     const foldResult = parse(path);
     return join('/')(foldResult);
 };
+/**
+ * Concatenates two path fragments and returns a normalized path.
+ */
 export const concat = a => b => {
     const s = stringConcat([a, '/', b]);
     return normalize(s);

package/text/ascii/module.f.d.ts

@@ -1,5 +1,12 @@
+/**
+ * Provides ASCII code point constants and helpers for creating numeric code points and inclusive ranges.
+ *
+ * @module
+ */
 import type { Range } from '../../types/range/module.f.ts';
+/** Returns the code point value of the first character in a string. */
 export declare const one: (s: string) => number;
+/** Returns an inclusive code point range from the first two characters in a string. */
 export declare const range: (s: string) => Range;
 /** 0x08 */
 export declare const backspace: number;

package/text/ascii/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * Provides ASCII code point constants and helpers for creating numeric code points and inclusive ranges.
+ *
+ * @module
+ */
 const at = (s) => (i) => {
     const r = s.codePointAt(i);
     if (r === void 0) {
@@ -5,7 +10,9 @@ const at = (s) => (i) => {
     }
     return r;
 };
+/** Returns the code point value of the first character in a string. */
 export const one = (s) => at(s)(0);
+/** Returns an inclusive code point range from the first two characters in a string. */
 export const range = (s) => {
     const f = at(s);
     const f0 = f(0);

package/text/sgr/module.f.d.ts

@@ -1,3 +1,9 @@
+/**
+ * ANSI Control Sequence Introducer (CSI) and Select Graphic Rendition (SGR)
+ * helpers for writing formatted terminal output and TTY-aware console streams.
+ *
+ * @module
+ */
 import type { Io, Writable } from "../../io/module.f.ts";
 export declare const backspace: string;
 type End = 'm';
@@ -15,17 +21,40 @@ export declare const csi: (end: End) => Csi;
  * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
  */
 export declare const sgr: Csi;
+/** Resets all SGR styles to terminal defaults. */
 export declare const reset: string;
+/** Enables bold/intense text rendering when supported by the terminal. */
 export declare const bold: string;
+/** Applies red foreground color to subsequent text. */
 export declare const fgRed: string;
+/** Applies green foreground color to subsequent text. */
 export declare const fgGreen: string;
 export type Stdout = {
+    /** Writes a string to the output stream. */
     readonly write: (s: string) => void;
 };
+/** Stateful writer that updates previously printed text in-place. */
 export type WriteText = (text: string) => WriteText;
+/**
+ * Creates a stateful text writer that rewrites the previous value using backspaces.
+ *
+ * @param stdout - Destination output stream.
+ * @returns A recursive writer that replaces prior text on each call.
+ */
 export declare const createConsoleText: (stdout: Stdout) => WriteText;
 export type CsiConsole = (s: string) => void;
+/**
+ * Creates a TTY-aware console function.
+ *
+ * For TTY destinations, ANSI SGR sequences are preserved.
+ * For non-TTY destinations, ANSI SGR sequences are stripped.
+ *
+ * @param io - Runtime IO bindings.
+ * @returns A function that targets a writable stream.
+ */
 export declare const console: ({ fs: { writeSync } }: Io) => (w: Writable) => CsiConsole;
+/** Writes to process stdout using a TTY-aware CSI console. */
 export declare const stdio: (io: Io) => CsiConsole;
+/** Writes to process stderr using a TTY-aware CSI console. */
 export declare const stderr: (io: Io) => CsiConsole;
 export {};

package/text/sgr/module.f.js

@@ -1,5 +1,9 @@
-// Co control codes
-// https://en.wikipedia.org/wiki/ANSI_escape_code#C0_control_codes
+/**
+ * ANSI Control Sequence Introducer (CSI) and Select Graphic Rendition (SGR)
+ * helpers for writing formatted terminal output and TTY-aware console streams.
+ *
+ * @module
+ */
 export const backspace = '\x08';
 const begin = '\x1b[';
 /**
@@ -15,9 +19,13 @@ export const csi = (end) => code => `${begin}${code.toString()}${end}`;
  * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
  */
 export const sgr = csi('m');
+/** Resets all SGR styles to terminal defaults. */
 export const reset = sgr(0);
+/** Enables bold/intense text rendering when supported by the terminal. */
 export const bold = sgr(1);
+/** Applies red foreground color to subsequent text. */
 export const fgRed = sgr(31);
+/** Applies green foreground color to subsequent text. */
 export const fgGreen = sgr(32);
 const { max } = Math;
 const replace = (old) => (text) => {
@@ -25,6 +33,12 @@ const replace = (old) => (text) => {
     const suffixLength = max(0, len - text.length);
     return backspace.repeat(len) + text + " ".repeat(suffixLength) + backspace.repeat(suffixLength);
 };
+/**
+ * Creates a stateful text writer that rewrites the previous value using backspaces.
+ *
+ * @param stdout - Destination output stream.
+ * @returns A recursive writer that replaces prior text on each call.
+ */
 export const createConsoleText = (stdout) => {
     const f = (old) => (text) => {
         stdout.write(replace(old)(text));
@@ -32,11 +46,22 @@ export const createConsoleText = (stdout) => {
     };
     return f('');
 };
+/**
+ * Creates a TTY-aware console function.
+ *
+ * For TTY destinations, ANSI SGR sequences are preserved.
+ * For non-TTY destinations, ANSI SGR sequences are stripped.
+ *
+ * @param io - Runtime IO bindings.
+ * @returns A function that targets a writable stream.
+ */
 export const console = ({ fs: { writeSync } }) => (w) => {
     const { isTTY } = w;
     return isTTY
         ? (s) => writeSync(w.fd, s + '\n')
         : (s) => writeSync(w.fd, s.replace(/\x1b\[[0-9;]*m/g, '') + '\n');
 };
+/** Writes to process stdout using a TTY-aware CSI console. */
 export const stdio = (io) => console(io)(io.process.stdout);
+/** Writes to process stderr using a TTY-aware CSI console. */
 export const stderr = (io) => console(io)(io.process.stderr);

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

@@ -16,10 +16,14 @@ export type DoK<O extends Operation, T, K extends O[0]> = DoKPR<O, T, K, Pr<O, K
 export type Do<O extends Operation, T> = DoK<O, T, O[0]>;
 export declare const pure: <T>(v: T) => Effect<never, T>;
 export declare const doFull: <O extends Operation, T, K extends O[0]>(cmd: K, param: Pr<O, K>[0], cont: (input: Pr<O, K>[1]) => Effect<O, T>) => Effect<O, T>;
-export declare const do_: <O extends Operation>(cmd: O[0]) => (param: Pr<O, O[0]>[0]) => Effect<O, Pr<O, O[0]>[1]>;
+export type Param<O extends Operation> = F<O>[0];
+export type Return<O extends Operation> = F<O>[1];
+export declare const do_: <O extends Operation>(cmd: O[0]) => (param: Param<O>) => Effect<O, Return<O>>;
+export declare const doRest: <O extends Operation>(cmd: O[0]) => (...param: Param<O>) => Effect<O, Return<O>>;
 export declare const begin: Effect<never, void>;
 export type ToAsyncOperationMap<O extends Operation> = {
     readonly [K in O[0]]: (payload: Pr<O, K>[0]) => Promise<Pr<O, K>[1]>;
 };
 export type F<O extends Operation> = Pr<O, O[0]>;
-export type Func<O extends Operation> = (_: F<O>[0]) => Effect<O, F<O>[1]>;
+export type Func<O extends Operation> = (_: Param<O>) => Effect<O, Return<O>>;
+export type RestFunc<O extends Operation> = (..._: Param<O>) => Effect<O, Return<O>>;

package/types/effects/module.f.js

@@ -12,4 +12,5 @@ export const doFull = (cmd, param, cont) => ({
     step: (f) => doFull(cmd, param, x => cont(x).step(f)),
 });
 export const do_ = (cmd) => (param) => doFull(cmd, param, pure);
+export const doRest = (cmd) => (...param) => do_(cmd)(param);
 export const begin = pure(undefined);

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

@@ -1,6 +1,7 @@
 import type { Vec } from '../../bit_vec/module.f.ts';
+import type { Nominal } from '../../nominal/module.f.ts';
 import type { Result } from '../../result/module.f.ts';
-import { type Effect, type Func, type Operation, type ToAsyncOperationMap } from '../module.f.ts';
+import { type Effect, type Func, type Operation, type RestFunc, type ToAsyncOperationMap } from '../module.f.ts';
 export type IoResult<T> = Result<T, unknown>;
 export type All = ['all', <T>(_: readonly Effect<never, T>[]) => readonly T[]];
 /**
@@ -19,7 +20,7 @@ export type MakeDirectoryOptions = {
 };
 export type MkdirParam = readonly [string, MakeDirectoryOptions?];
 export type Mkdir = readonly ['mkdir', (_: MkdirParam) => IoResult<void>];
-export declare const mkdir: (...p: MkdirParam) => Effect<Mkdir, IoResult<void>>;
+export declare const mkdir: RestFunc<Mkdir>;
 export type ReadFile = readonly ['readFile', (_: string) => IoResult<Vec>];
 export declare const readFile: Func<ReadFile>;
 /**
@@ -36,17 +37,26 @@ export type ReaddirOptions = {
 };
 export type ReaddirParam = readonly [string, ReaddirOptions];
 export type Readdir = readonly ['readdir', (_: ReaddirParam) => IoResult<readonly Dirent[]>];
-export declare const readdir: (...p: ReaddirParam) => Effect<Readdir, IoResult<readonly Dirent[]>>;
+export declare const readdir: RestFunc<Readdir>;
 export type WriteFileParam = readonly [string, Vec];
 export type WriteFile = readonly ['writeFile', (_: WriteFileParam) => IoResult<void>];
-export declare const writeFile: (...p: WriteFileParam) => Effect<WriteFile, IoResult<void>>;
+export declare const writeFile: RestFunc<WriteFile>;
 export type Fs = Mkdir | ReadFile | Readdir | WriteFile;
 export type Error = ['error', (_: string) => void];
 export declare const error: Func<Error>;
 export type Log = ['log', (_: string) => void];
 export declare const log: Func<Log>;
 export type Console = Log | Error;
-export type NodeOp = All | Fetch | Console | Fs;
+export type Server = Nominal<'server', `160855c4f69310fece3273c1853ac32de43dee1eb41bf59d821917f8eebe9272`, unknown>;
+export type IncomingMessage = {};
+export type ServerResponse = {};
+export type RequestListener = (_: IncomingMessage) => ServerResponse;
+export type CreateServer = ['createServer', (_: RequestListener) => Server];
+export declare const createServer: Func<CreateServer>;
+export type Listen = ['listen', (_: readonly [Server, number]) => void];
+export declare const listen: RestFunc<Listen>;
+export type Http = CreateServer | Listen;
+export type NodeOp = All | Fetch | Console | Fs | Http;
 export type NodeEffect<T> = Effect<NodeOp, T>;
 export type NodeOperationMap = ToAsyncOperationMap<NodeOp>;
 export type NodeProgram = (argv: readonly string[]) => Effect<NodeOp, number>;

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

@@ -1,4 +1,4 @@
-import { do_ } from "../module.f.js";
+import { doRest, do_ } from "../module.f.js";
 /**
  * To run the operation `O` should be known by the runner/engine.
  * This is the reason why we merge `O` with `All` in the resulted `Effect`.
@@ -9,9 +9,11 @@ import { do_ } from "../module.f.js";
 export const all = (...a) => do_('all')(a);
 export const both = (a) => (b) => all(a, b);
 export const fetch = do_('fetch');
-export const mkdir = (...p) => do_('mkdir')(p);
+export const mkdir = doRest('mkdir');
 export const readFile = do_('readFile');
-export const readdir = (...p) => do_('readdir')(p);
-export const writeFile = (...p) => do_('writeFile')(p);
+export const readdir = doRest('readdir');
+export const writeFile = doRest('writeFile');
 export const error = do_('error');
 export const log = do_('log');
+export const createServer = do_('createServer');
+export const listen = doRest('listen');

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

@@ -3,11 +3,11 @@
  *
  * @module
  */
+import { todo } from "../../../../dev/module.f.js";
 import { parse } from "../../../../path/module.f.js";
 import { isVec } from "../../../bit_vec/module.f.js";
 import { error, ok } from "../../../result/module.f.js";
 import { run } from "../../mock/module.f.js";
-import { pure } from "../../module.f.js";
 export const emptyState = {
     stdout: '',
     stderr: '',
@@ -115,5 +115,7 @@ const map = {
     readFile,
     readdir: (state, [path, { recursive }]) => readdir(path, recursive === true)(state, path),
     writeFile: (state, [path, payload]) => writeFile(payload)(state, path),
+    createServer: todo,
+    listen: todo,
 };
 export const virtual = run(map);

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

@@ -3,8 +3,20 @@
  *
  * @module
  */
+/**
+ * Nominal type.
+ *
+ * It doesn't allow `===` between different nominal types.
+ * It doesn't allow `<`, `>`, `<=`, `>=` comparisons at all.
+ */
 export type Nominal<N extends string, R extends string, B> = symbol & {
     [k in N]: readonly [R, B];
 };
+/**
+ * note: It should compiles into `identity` and no-ops at runtime.
+ */
 export declare const asNominal: <N extends string, R extends string, B>(b: B) => Nominal<N, R, B>;
+/**
+ * note: It should compiles into `identity` and no-ops at runtime.
+ */
 export declare const asBase: <T extends string, R extends string, B>(n: Nominal<T, R, B>) => B;

package/types/nominal/module.f.js

@@ -1,4 +1,13 @@
-/// note: It should compiles into `identity` and no-ops at runtime.
+/**
+ * Nominal typing helpers for branded TypeScript types.
+ *
+ * @module
+ */
+/**
+ * note: It should compiles into `identity` and no-ops at runtime.
+ */
 export const asNominal = (b) => b;
-/// note: It should compiles into `identity` and no-ops at runtime.
+/**
+ * note: It should compiles into `identity` and no-ops at runtime.
+ */
 export const asBase = (n) => n;