functionalscript 0.43.1 → 0.44.0

package/fjs/types/ts/types.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Types for the TypeScript source emitter: the `Equal` compile-time predicate
+ * and the `Printer` interface.
+ *
+ * @module
+ */
+export type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
+/**
+ * Functions for emitting TypeScript type expression strings.
+ */
+export type Printer = {
+    readonly tuple: (types: readonly string[]) => string;
+    readonly struct: (fields: readonly (readonly [string, string])[]) => string;
+    readonly array: (type: string) => string;
+    readonly record: (type: string) => string;
+};

package/fjs/types/ts/types.js

@@ -0,0 +1,8 @@
+/**
+ * Types for the TypeScript source emitter: the `Equal` compile-time predicate
+ * and the `Printer` interface.
+ *
+ * @module
+ */
+export {};
+// type T4 = {[k:string]?: bigint} //< compilation error.

package/fjs/types/uint8array/module.f.d.mts

@@ -0,0 +1,31 @@
+/**
+ * Conversions between `Uint8Array` values and bit vectors.
+ *
+ * @deprecated FunctionalScript represents byte data as `bigint`-based bit
+ * vectors (`Vec` from `fjs/types/bit_vec`). Use `utf8`/`utf8ToString` from
+ * `fjs/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
+ */
+import type { Vec } from '../bit_vec/types.ts';
+import type { List } from '../list/types.ts';
+/**
+ * Converts a Uint8Array into an MSB-first bit vector.
+ *
+ * @type {(input: Uint8Array) => Vec}
+ */
+export declare const toVec: (input: Uint8Array) => Vec;
+/** @type {(input: List<Uint8Array>) => Vec} */
+export declare const listToVec: (input: List<Uint8Array>) => Vec;
+/**
+ * Converts an MSB-first bit vector into a Uint8Array.
+ *
+ * @type {(input: Vec) => Uint8Array}
+ */
+export declare const fromVec: (input: Vec) => Uint8Array;
+/** @type {(input: Uint8Array) => string} */
+export declare const decodeUtf8: (input: Uint8Array) => string;
+/** @type {(input: string) => Uint8Array} */
+export declare const encodeUtf8: (input: string) => Uint8Array;

package/fjs/types/uint8array/module.f.mjs

@@ -0,0 +1,53 @@
+/**
+ * Conversions between `Uint8Array` values and bit vectors.
+ *
+ * @deprecated FunctionalScript represents byte data as `bigint`-based bit
+ * vectors (`Vec` from `fjs/types/bit_vec`). Use `utf8`/`utf8ToString` from
+ * `fjs/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
+ */
+
+import { assert, assertNotNullish } from '../../asserts/module.f.mjs'
+import { utf8, utf8ToString } from '../../text/module.f.mjs'
+import { maxLengthBytes, msb, tryU8ListToVec, u8List, u8ListToVec } from '../bit_vec/module.f.mjs'
+/** @import { Vec } from '../bit_vec/types.ts' */
+import { compose } from '../function/module.f.mjs'
+import { flat, fromArrayLike, iterable, map } from '../list/module.f.mjs'
+/** @import { List } from '../list/types.ts' */
+
+const u8ListToVecMsb = u8ListToVec(msb)
+const tryU8ListToVecMsb = tryU8ListToVec(msb)
+const u8ListMsb = u8List(msb)
+
+/**
+ * Converts a Uint8Array into an MSB-first bit vector.
+ *
+ * @type {(input: Uint8Array) => Vec}
+ */
+export const toVec = input => {
+    assert(input.length <= maxLengthBytes, "the array is too big")
+    return u8ListToVecMsb(fromArrayLike(input))
+}
+
+const m = map(fromArrayLike)
+
+/** @type {(input: List<Uint8Array>) => Vec} */
+export const listToVec = input =>
+    assertNotNullish(tryU8ListToVecMsb(flat(m(input))), "the array is too big")
+
+/**
+ * Converts an MSB-first bit vector into a Uint8Array.
+ *
+ * @type {(input: Vec) => Uint8Array}
+ */
+export const fromVec = input =>
+    Uint8Array.from(iterable(u8ListMsb(input)))
+
+/** @type {(input: Uint8Array) => string} */
+export const decodeUtf8 = compose(toVec)(utf8ToString)
+
+/** @type {(input: string) => Uint8Array} */
+export const encodeUtf8 = compose(utf8)(fromVec)

package/fjs/types/uint8array/proof.f.d.mts

@@ -0,0 +1,17 @@
+export declare const proof: {
+    empty: () => void;
+    roundTrip: () => void;
+    unalignedLength: () => void;
+    encodeUtf8Empty: () => void;
+    encodeUtf8Ascii: () => void;
+    encodeUtf8Multibyte: () => void;
+    decodeUtf8Ascii: () => void;
+    decodeUtf8Multibyte: () => void;
+    utf8RoundTrip: () => void;
+    listToVec: () => void;
+    maxLength: () => import("../bit_vec/types.ts").Vec;
+    throw: {
+        toVec: () => import("../bit_vec/types.ts").Vec;
+        listToVec: () => import("../bit_vec/types.ts").Vec;
+    };
+};

package/fjs/types/uint8array/proof.f.mjs

@@ -0,0 +1,73 @@
+import { maxLengthBytes, vec } from '../bit_vec/module.f.mjs'
+import { toVec, fromVec, listToVec, decodeUtf8, encodeUtf8 } from './module.f.mjs'
+import { strictEqual } from '../function/operator/module.f.mjs'
+import { equal, fromArrayLike } from '../list/module.f.mjs'
+import { assert } from '../../asserts/module.f.mjs'
+
+/**
+ * @template T
+ * @param {T} a
+ * @param {T} b
+ */
+const assertEq = (a, b) => {
+    assert(a === b, [a, b])
+}
+
+/** @type {(a: Uint8Array, b: Uint8Array) => void} */
+const assertArrayEq = (a, b) => {
+    assert(equal(strictEqual)(fromArrayLike(a))(fromArrayLike(b)), [a, b])
+}
+
+export const proof = {
+    empty: () => {
+        const input = new Uint8Array()
+        const vec = toVec(input)
+        const output = fromVec(vec)
+        assertArrayEq(output, input)
+    },
+    roundTrip: () => {
+        const input = Uint8Array.from([0, 1, 2, 3, 255])
+        const vec = toVec(input)
+        const output = fromVec(vec)
+        assertArrayEq(output, input)
+    },
+    unalignedLength: () => {
+        const input = vec(4n)(0xFn)
+        const output = fromVec(input)
+        assertArrayEq(output, Uint8Array.from([0xF0]))
+    },
+    encodeUtf8Empty: () => {
+        const output = encodeUtf8('')
+        assertArrayEq(output, new Uint8Array())
+    },
+    encodeUtf8Ascii: () => {
+        const output = encodeUtf8('Hi!')
+        assertArrayEq(output, Uint8Array.from([72, 105, 33]))
+    },
+    encodeUtf8Multibyte: () => {
+        const output = encodeUtf8('✓')
+        assertArrayEq(output, Uint8Array.from([0xE2, 0x9C, 0x93]))
+    },
+    decodeUtf8Ascii: () => {
+        const output = decodeUtf8(Uint8Array.from([102, 115]))
+        assertEq(output, 'fs')
+    },
+    decodeUtf8Multibyte: () => {
+        const output = decodeUtf8(Uint8Array.from([0xE2, 0x9C, 0x93]))
+        assertEq(output, '✓')
+    },
+    utf8RoundTrip: () => {
+        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]))
+    },
+    maxLength: () => toVec(new Uint8Array(Number(maxLengthBytes))),
+    throw: {
+        toVec: () => toVec(new Uint8Array(Number(maxLengthBytes) + 1)),
+        listToVec: () => listToVec([new Uint8Array(Number(maxLengthBytes)), Uint8Array.from([0])]),
+    },
+}

package/fjs/website/module.f.d.mts

@@ -0,0 +1,8 @@
+/**
+ * Static website generation program for project landing content.
+ *
+ * @module
+ */
+import type { WriteFile } from '../effects/node/types.ts';
+import type { Effect } from '../effects/types.ts';
+export declare const main: () => Effect<WriteFile, number>;

package/fjs/website/module.f.mjs

@@ -0,0 +1,24 @@
+/**
+ * Static website generation program for project landing content.
+ *
+ * @module
+ */
+
+import { htmlUtf8 } from '../media/html/module.f.mjs'
+import { writeFile } from '../effects/node/module.f.mjs'
+/** @import { WriteFile } from '../effects/node/types.ts' */
+import { pure, step } from '../effects/module.f.mjs'
+/** @import { Effect } from '../effects/types.ts' */
+
+const html = htmlUtf8()(
+    ['a',
+        { href: 'https://github.com/functionalscript/functionalscript' },
+        'GitHub Repository'
+    ])
+
+/** @type {Effect<WriteFile, number>} */
+const program = step(
+    writeFile('index.html', html),
+    () => pure(0))
+
+export const main = () => program

package/fjs/website/proof.f.mjs

@@ -0,0 +1,14 @@
+import { main } from './module.f.mjs'
+import { emptyState, virtual } from '../effects/node/virtual/module.f.mjs'
+import { assertEq, assertNotNullish } from '../asserts/module.f.mjs'
+
+export const proof = {
+    main: () => {
+        assertNotNullish(main(), 'expected a program effect')
+    },
+    run: () => {
+        const state = { ...emptyState, root: { '.github': { workflows: {} } } }
+        const [_, result] = virtual(state)(main())
+        assertEq(result, 0)
+    },
+}

package/package.json

@@ -1,28 +1,30 @@
 {
   "name": "functionalscript",
-  "version": "0.43.1",
+  "version": "0.44.0",
   "type": "module",
   "files": [
     "**/*.js",
-    "**/*.d.ts"
+    "**/*.d.ts",
+    "**/*.mjs",
+    "**/*.d.mts"
   ],
   "description": "FunctionalScript is a purely functional subset of JavaScript",
   "scripts": {
-    "prepack": "tsc --NoEmit false",
-    "test": "tsc && node ./fjs/module.ts t",
-    "cov": "node --test --experimental-test-coverage --test-coverage-include=**/module.f.ts --test-coverage-include=**/module.f.mjs",
-    "start": "node ./fjs/module.ts",
-    "ci-update": "node ./fjs/module.ts ci",
-    "dev-update": "node ./fjs/module.ts r ./fjs/dev/update/module.f.ts",
+    "prepack": "tsc --noEmit false --emitDeclarationOnly && tsc --noEmit false --declaration false",
+    "test": "tsc && node ./fjs/module.mjs t",
+    "cov": "node --test --experimental-test-coverage --test-coverage-include=**/module.f.mjs fjs/emergent_testing/all.test.ts",
+    "start": "node ./fjs/module.mjs",
+    "ci-update": "node ./fjs/module.mjs ci && node ./fjs/module.mjs r ./fjs/nanvm/update/module.f.mjs",
+    "dev-update": "node ./fjs/module.mjs r ./fjs/dev/update/module.f.mjs",
     "update": "npm run ci-update && npm install && deno install && bun install",
-    "index-html": "node ./fjs/module.ts r ./fjs/website/module.f.ts",
+    "index-html": "node ./fjs/module.mjs r ./fjs/website/module.f.mjs",
     "website": "npm run prepack && npm run index-html"
   },
   "engines": {
     "node": ">=22"
   },
   "bin": {
-    "fjs": "fjs/module.js"
+    "fjs": "fjs/module.mjs"
   },
   "repository": {
     "type": "git",

package/todo/proof.f.d.mts

@@ -0,0 +1,22 @@
+/** @typedef {`<html>${string}</html>`} _TemplateType */
+export type _TemplateType = `<html>${string}</html>`;
+export declare const proof: {
+    literal: () => void;
+    ownProperty: {
+        null: {
+            throw: () => PropertyDescriptor | undefined;
+        };
+        undefined: {
+            throw: () => PropertyDescriptor | undefined;
+        };
+        bool: () => void;
+        array: () => void;
+        object: {
+            null: () => void;
+            undefined: () => void;
+        };
+        string: {
+            number: () => void;
+        };
+    };
+};

package/todo/proof.f.mjs

@@ -0,0 +1,59 @@
+/** @typedef {`<html>${string}</html>`} _TemplateType */
+
+/** @type {(a: unknown) => (i: any) => unknown} */
+const at = a => i => Object.getOwnPropertyDescriptor(a, i)?.value
+
+/** @type {(...x: [readonly string[]]) => [readonly string[]]} */
+const utf8 = (...x) => x
+
+export const proof = {
+    literal: () => {
+        const x = utf8`17`
+        /** @type {_TemplateType} */
+        const m = '<html>Hello</html>'
+    },
+    ownProperty: {
+        null: {
+            throw: () => Object.getOwnPropertyDescriptor(null, 0),
+        },
+        undefined: {
+            throw: () => Object.getOwnPropertyDescriptor(undefined, 0),
+        },
+        bool: () => {
+            const v = at(true)('x')
+            if (v !== undefined) {
+                throw v
+            }
+        },
+        array: () => {
+            const a = ['42']
+            {
+                const v = at(a)('0')
+                if (v !== '42') { throw v }
+            }
+            {
+                const v = at(a)(0)
+                if (v !== '42') { throw v }
+            }
+        },
+        object: {
+            null: () => {
+                const o = { null: 'hello' }
+                const v = at(o)(null)
+                if (v !== 'hello') { throw v }
+            },
+            undefined: () => {
+                const o = { undefined: 'hello' }
+                const v = at(o)(undefined)
+                if (v !== 'hello') { throw v }
+            }
+        },
+        string: {
+            number: () => {
+                const o = 'hello'
+                const v = at(o)(1)
+                if (v !== 'e') { throw v }
+            }
+        }
+    }
+}

package/fjs/asn.1/module.f.d.ts

@@ -1,62 +0,0 @@
-import { type Vec } from "../types/bit_vec/module.f.ts";
-/** ASN.1 tag number. */
-type Tag = bigint;
-/** ASN.1 universal BOOLEAN tag. */
-export declare const boolean = 1n;
-/** ASN.1 universal INTEGER tag. */
-export declare const integer = 2n;
-/** ASN.1 universal OCTET STRING tag. */
-export declare const octetString = 4n;
-/** ASN.1 universal OBJECT IDENTIFIER tag. */
-export declare const objectIdentifier = 6n;
-export declare const constructedSequence = 48n;
-export declare const constructedSet = 49n;
-/** Raw ASN.1 TLV tuple. */
-export type Raw = readonly [Tag, Vec];
-/** Encodes a raw ASN.1 TLV tuple into a bit vector. */
-export declare const encodeRaw: ([tag, value]: Raw) => Vec;
-/** Decodes a raw ASN.1 TLV tuple and returns the remaining input. */
-export declare const decodeRaw: (v: Vec) => readonly [Raw, Vec];
-/** Encodes a JavaScript boolean as an ASN.1 BOOLEAN value. */
-export declare const encodeBoolean: (b: boolean) => Vec;
-/** Decodes an ASN.1 BOOLEAN value. */
-export declare const decodeBoolean: (v: Vec) => boolean;
-/** Encodes a signed bigint using ASN.1 INTEGER two's complement representation. */
-export declare const encodeInteger: (uint: bigint) => Vec;
-/** Decodes an ASN.1 INTEGER encoded in two's complement. */
-export declare const decodeInteger: (v: Vec) => bigint;
-/** Encodes an OCTET STRING value. */
-export declare const encodeOctetString: (v: Vec) => Vec;
-/** Decodes an OCTET STRING value. */
-export declare const decodeOctetString: (v: Vec) => Vec;
-/** ASN.1 OBJECT IDENTIFIER components. */
-export type ObjectIdentifier = readonly bigint[];
-/** Encodes an OBJECT IDENTIFIER value. */
-export declare const encodeObjectIdentifier: (oid: ObjectIdentifier) => Vec;
-/** Decodes an OBJECT IDENTIFIER value. */
-export declare const decodeObjectIdentifier: (v: Vec) => ObjectIdentifier;
-/** ASN.1 ordered collection of records. */
-export type Sequence = readonly Record[];
-/** Encodes a SEQUENCE payload from ordered records. */
-export declare const encodeSequence: (...records: Sequence) => Vec;
-/** Decodes a SEQUENCE payload into records. */
-export declare const decodeSequence: (v: Vec) => Sequence;
-/** ASN.1 SET represented as a sequence of records. */
-export type Set = Sequence;
-/** Encodes a SET payload with canonical byte ordering. */
-export declare const encodeSet: (...records: Sequence) => Vec;
-/** Decodes a SET payload. */
-export declare const decodeSet: (v: Vec) => Sequence;
-/** Supported ASN.1 record variants. */
-export type SupportedRecord = readonly [typeof boolean, boolean] | readonly [typeof integer, bigint] | readonly [typeof octetString, Vec] | readonly [typeof objectIdentifier, ObjectIdentifier] | readonly [typeof constructedSequence, Sequence] | readonly [typeof constructedSet, Set];
-/**
- * For unsupported tags, we just store the raw value including the tag and length,
- * so that it can be re-encoded without loss of information.
- */
-export type UnsupportedRecord = Vec;
-export type Record = SupportedRecord | UnsupportedRecord;
-/** Encodes a supported ASN.1 record as TLV. */
-export declare const encode: (record: Record) => Vec;
-/** Decodes one supported ASN.1 record and returns the remaining input. */
-export declare const decode: (v: Vec) => readonly [Record, Vec];
-export {};