@raoh/core 0.9.0-dev.15.20261004151401.ge5893e0cc07d

package/dist/text.js

@@ -0,0 +1,204 @@
+// Recognizers for the text formats the string operations read: e-mail addresses, IP addresses,
+// ULIDs, CUIDs, UUIDs and URIs. Each is written from the RFC it names, in ASCII.
+const ATEXT = "A-Za-z0-9!#$%&'*+\\-/=?^_`{|}~";
+const LOCAL_PART = new RegExp(`^[${ATEXT}]+(?:\\.[${ATEXT}]+)*$`);
+const LABEL = /^[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?$/;
+/**
+ * Whether `text` is in the ASCII lexical profile of RFC 5321's Mailbox the `email` operation
+ * reads: atoms of atext joined by single dots, of at most 64 octets, `@`, and labels joined by
+ * single dots, each at most 63 octets, the domain at most 255 and the whole at most 254.
+ */
+export function isEmail(text) {
+    const at = text.lastIndexOf("@");
+    if (at < 0 || text.length > 254) {
+        return false;
+    }
+    const local = text.slice(0, at);
+    const domain = text.slice(at + 1);
+    return (local.length <= 64 &&
+        LOCAL_PART.test(local) &&
+        domain.length <= 255 &&
+        domain.split(".").every((label) => label.length <= 63 && LABEL.test(label)));
+}
+const DEC_OCTET = "(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])";
+const IPV4 = new RegExp(`^${DEC_OCTET}(?:\\.${DEC_OCTET}){3}$`);
+/** Whether `text` is RFC 3986's IPv4address: four decimal numbers from 0 to 255, no leading zero. */
+export function isIpv4(text) {
+    return IPV4.test(text);
+}
+/**
+ * The sixteen bytes of RFC 3986's IPv6address, without a zone: eight groups of one to four
+ * hexadecimal digits, at most one `::` standing for one or more zero groups, and optionally an
+ * IPv4 address in place of the last two groups. `undefined` where `text` is not one.
+ */
+function ipv6Groups(text) {
+    const halves = text.split("::");
+    if (halves.length > 2) {
+        return undefined;
+    }
+    const groupsOf = (half, last) => {
+        if (half === "") {
+            return [];
+        }
+        const parts = half.split(":");
+        const out = [];
+        for (let i = 0; i < parts.length; i += 1) {
+            const part = parts[i];
+            if (last && i === parts.length - 1 && part.includes(".")) {
+                if (!isIpv4(part)) {
+                    return undefined;
+                }
+                const [a, b, c, d] = part.split(".").map(Number);
+                out.push((a << 8) | b, (c << 8) | d);
+            }
+            else if (/^[0-9A-Fa-f]{1,4}$/.test(part)) {
+                out.push(Number.parseInt(part, 16));
+            }
+            else {
+                return undefined;
+            }
+        }
+        return out;
+    };
+    if (halves.length === 1) {
+        const groups = groupsOf(text, true);
+        return groups !== undefined && groups.length === 8 ? groups : undefined;
+    }
+    const head = groupsOf(halves[0], false);
+    const tail = groupsOf(halves[1], true);
+    if (head === undefined || tail === undefined || head.length + tail.length > 7) {
+        return undefined;
+    }
+    return [...head, ...new Array(8 - head.length - tail.length).fill(0), ...tail];
+}
+/**
+ * Whether `text` is an IPv6 address as the `ipv6` operation reads one: RFC 3986's IPv6address,
+ * optionally followed by `%` and a zone ID (non-empty, without `%` or U+0000) where the address is
+ * link-local unicast (fe80::/10) or multicast with a scope from 1 to D.
+ */
+export function isIpv6(text) {
+    const percent = text.indexOf("%");
+    const address = percent < 0 ? text : text.slice(0, percent);
+    const groups = ipv6Groups(address);
+    if (groups === undefined) {
+        return false;
+    }
+    if (percent < 0) {
+        return true;
+    }
+    const zone = text.slice(percent + 1);
+    if (zone === "" || zone.includes("%") || zone.includes("\u0000")) {
+        return false;
+    }
+    const first = groups[0];
+    const linkLocal = (first & 0xffc0) === 0xfe80;
+    const scope = first & 0x000f;
+    const multicast = (first & 0xff00) === 0xff00 && scope >= 0x1 && scope <= 0xd;
+    return linkLocal || multicast;
+}
+const ULID = /^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/;
+/** Whether `text` is a ULID in its canonical text form, of at most 128 bits. */
+export function isUlid(text) {
+    return ULID.test(text);
+}
+const CUID = /^c[a-z0-9]{24}$/;
+/** Whether `text` is a CUID of version 1. */
+export function isCuid(text) {
+    return CUID.test(text);
+}
+const UUID = /^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}$/;
+/** Whether `text` is a UUID's 32 hexadecimal digits grouped 8-4-4-4-12, in either case. */
+export function isUuid(text) {
+    return UUID.test(text);
+}
+const UNRESERVED = "A-Za-z0-9\\-._~";
+const SUB_DELIMS = "!$&'()*+,;=";
+const PCT_ENCODED = "%[0-9A-Fa-f]{2}";
+const PCHAR = `(?:[${UNRESERVED}${SUB_DELIMS}:@]|${PCT_ENCODED})`;
+const SCHEME = /^[A-Za-z][A-Za-z0-9+\-.]*$/;
+const USERINFO = new RegExp(`^(?:[${UNRESERVED}${SUB_DELIMS}:]|${PCT_ENCODED})*$`);
+const REG_NAME = new RegExp(`^(?:[${UNRESERVED}${SUB_DELIMS}]|${PCT_ENCODED})*$`);
+const IPV_FUTURE = new RegExp(`^[vV][0-9A-Fa-f]+\\.[${UNRESERVED}${SUB_DELIMS}:]+$`);
+const PORT = /^[0-9]*$/;
+const PATH_ABEMPTY = new RegExp(`^(?:/${PCHAR}*)*$`);
+const PATH_ABSOLUTE = new RegExp(`^/(?:${PCHAR}+(?:/${PCHAR}*)*)?$`);
+const PATH_ROOTLESS = new RegExp(`^${PCHAR}+(?:/${PCHAR}*)*$`);
+const QUERY = new RegExp(`^(?:${PCHAR}|[/?])*$`);
+/**
+ * The scheme and host of `text` where it is a URI as the URI production of RFC 3986 section 3
+ * derives it, and `undefined` where it is not: a relative reference is not one, and neither is an
+ * IPv6 host with a zone identifier.
+ */
+export function uriParts(text) {
+    const colon = text.indexOf(":");
+    if (colon < 0) {
+        return undefined;
+    }
+    const scheme = text.slice(0, colon);
+    if (!SCHEME.test(scheme)) {
+        return undefined;
+    }
+    let rest = text.slice(colon + 1);
+    const hash = rest.indexOf("#");
+    if (hash >= 0) {
+        if (!QUERY.test(rest.slice(hash + 1))) {
+            return undefined;
+        }
+        rest = rest.slice(0, hash);
+    }
+    const question = rest.indexOf("?");
+    if (question >= 0) {
+        if (!QUERY.test(rest.slice(question + 1))) {
+            return undefined;
+        }
+        rest = rest.slice(0, question);
+    }
+    if (!rest.startsWith("//")) {
+        const path = rest === "" || PATH_ABSOLUTE.test(rest) || PATH_ROOTLESS.test(rest);
+        return path ? { scheme, host: undefined } : undefined;
+    }
+    const afterSlashes = rest.slice(2);
+    const slash = afterSlashes.indexOf("/");
+    const authority = slash < 0 ? afterSlashes : afterSlashes.slice(0, slash);
+    const path = slash < 0 ? "" : afterSlashes.slice(slash);
+    if (!PATH_ABEMPTY.test(path)) {
+        return undefined;
+    }
+    const host = hostOf(authority);
+    return host === undefined ? undefined : { scheme, host };
+}
+/** The host of an authority, `[ userinfo "@" ] host [ ":" port ]`, or `undefined` where it is not one. */
+function hostOf(authority) {
+    const at = authority.indexOf("@");
+    if (at >= 0 && !USERINFO.test(authority.slice(0, at))) {
+        return undefined;
+    }
+    const hostAndPort = at >= 0 ? authority.slice(at + 1) : authority;
+    let host;
+    let port;
+    if (hostAndPort.startsWith("[")) {
+        const close = hostAndPort.indexOf("]");
+        if (close < 0) {
+            return undefined;
+        }
+        host = hostAndPort.slice(0, close + 1);
+        const after = hostAndPort.slice(close + 1);
+        if (after !== "" && !after.startsWith(":")) {
+            return undefined;
+        }
+        port = after.slice(1);
+        const literal = host.slice(1, -1);
+        if (ipv6Groups(literal) === undefined && !IPV_FUTURE.test(literal)) {
+            return undefined;
+        }
+    }
+    else {
+        const colon = hostAndPort.indexOf(":");
+        host = colon < 0 ? hostAndPort : hostAndPort.slice(0, colon);
+        port = colon < 0 ? "" : hostAndPort.slice(colon + 1);
+        if (!REG_NAME.test(host)) {
+            return undefined;
+        }
+    }
+    return PORT.test(port) ? host : undefined;
+}

package/dist/wire.d.ts

@@ -0,0 +1,36 @@
+import { JsonNumber } from "./input.ts";
+import type { Issue } from "./issue.ts";
+import { type MessageResolver } from "./messages.ts";
+/** A JSON value as this library writes one: every number a JsonNumber of its exact text. */
+export type Wire = null | boolean | string | JsonNumber | readonly Wire[] | {
+    readonly [member: string]: Wire;
+};
+/**
+ * An issue held in another's metadata, the candidates of a `one_of_failed`, as the
+ * specification observes the `issues` type: a path, a code, a message and metadata, and no
+ * message key.
+ */
+export interface NestedIssueWire {
+    readonly path: string;
+    readonly code: string;
+    readonly message: string;
+    readonly meta: {
+        readonly [name: string]: Wire;
+    };
+}
+/** An issue as JSON: a nested issue's parts, and its message key. */
+export interface IssueWire extends NestedIssueWire {
+    readonly messageKey: string;
+}
+/**
+ * `issue` as JSON: its path as a JSON Pointer, its code, its message key, its sentence as
+ * `resolver` writes it (or as it was given), and its metadata, each value as its observation.
+ */
+export declare function issueWire(issue: Issue, resolver?: MessageResolver): IssueWire;
+/** `issue` as JSON where it is held in another issue's metadata: everything but its message key. */
+export declare function nestedIssueWire(issue: Issue, resolver?: MessageResolver): NestedIssueWire;
+/**
+ * A metadata value as its observation. A JavaScript number is an int32 where it is an integer
+ * and a float64 otherwise; a value of another class is written as what its `toJSON` gives.
+ */
+export declare function wire(value: unknown, resolver?: MessageResolver): Wire;

package/dist/wire.js

@@ -0,0 +1,92 @@
+// How issues and the values of the value model are written as JSON.
+//
+// There is one way, and it is the Raoh Specification's observation of a value
+// (spec/observation.md): an integer is a JSON number of all its digits, a float its canonical
+// decimal or, where JSON cannot carry it, a tag ({"float": "-0"}, {"float": "NaN"},
+// {"float": "+Infinity"}, {"float": "-Infinity"}), a decimal the text of its coefficient and
+// scale, a list an array, a record an object, and the issues of a one_of_failed an array of
+// issues. Every number is held as a JsonNumber of the text to write, so none is rounded on the
+// way out.
+import { Decimal } from "./decimal.js";
+import { Float, floatJson } from "./float.js";
+import { JsonNumber, lexemeOf } from "./input.js";
+import { Issues } from "./issue.js";
+import { Messages } from "./messages.js";
+import { ValueSet } from "./set.js";
+import { ofThisCopy } from "./copy.js";
+/**
+ * `issue` as JSON: its path as a JSON Pointer, its code, its message key, its sentence as
+ * `resolver` writes it (or as it was given), and its metadata, each value as its observation.
+ */
+export function issueWire(issue, resolver = Messages.english) {
+    const { path, code, message, meta } = nestedIssueWire(issue, resolver);
+    return { path, code, messageKey: issue.messageKey, message, meta };
+}
+/** `issue` as JSON where it is held in another issue's metadata: everything but its message key. */
+export function nestedIssueWire(issue, resolver = Messages.english) {
+    return {
+        path: issue.path.toString(),
+        code: issue.code,
+        message: issue.message(resolver),
+        meta: record(issue.meta, resolver),
+    };
+}
+/**
+ * A metadata value as its observation. A JavaScript number is an int32 where it is an integer
+ * and a float64 otherwise; a value of another class is written as what its `toJSON` gives.
+ */
+export function wire(value, resolver = Messages.english) {
+    switch (typeof value) {
+        case "boolean":
+        case "string":
+            return value;
+        case "bigint":
+            return new JsonNumber(value.toString());
+        case "number":
+            return Number.isInteger(value) && !Object.is(value, -0) ? new JsonNumber(String(value)) : floatJson(value, 64);
+        case "undefined":
+            return null;
+    }
+    if (value === null || ofThisCopy(value, JsonNumber, "JsonNumber")) {
+        return value;
+    }
+    // A value of the value model is written as its observation writes it, before it is asked whether
+    // the input model reads it as a number: a Decimal is one there too, and its observation is a string.
+    if (ofThisCopy(value, Float, "Float")) {
+        return floatJson(value.value, value.width);
+    }
+    if (ofThisCopy(value, Decimal, "Decimal")) {
+        return value.toString();
+    }
+    // A number the input model reads from an object, which JSON.rawJSON makes, is written as the
+    // number it is, by the one rule that reads its text. Metadata is not input, so what is asked is
+    // only whether the value is such a number, and not whether it is a value of the input model.
+    const lexeme = lexemeOf(value);
+    if (lexeme !== undefined) {
+        return new JsonNumber(lexeme);
+    }
+    if (ofThisCopy(value, Issues, "Issues")) {
+        return value.list.map((issue) => nestedIssueWire(issue, resolver));
+    }
+    if (Array.isArray(value) || ofThisCopy(value, ValueSet, "ValueSet")) {
+        return [...value].map((item) => wire(item, resolver));
+    }
+    if (value instanceof Map) {
+        return record(Object.fromEntries(value), resolver);
+    }
+    if (typeof value === "object") {
+        const toJSON = value.toJSON;
+        if (typeof toJSON === "function") {
+            return wire(toJSON.call(value), resolver);
+        }
+        return record(value, resolver);
+    }
+    throw new TypeError(`a ${typeof value} has no JSON`);
+}
+function record(fields, resolver) {
+    const out = {};
+    for (const [name, value] of Object.entries(fields)) {
+        Object.defineProperty(out, name, { value: wire(value, resolver), enumerable: true, writable: true, configurable: true });
+    }
+    return out;
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@raoh/core",
+  "version": "0.9.0-dev.15.20261004151401.ge5893e0cc07d",
+  "description": "Decoders that turn untyped boundary input into typed domain values, reporting every issue with its path",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/raoh-project/raoh-ts.git"
+  },
+  "keywords": [
+    "decoder",
+    "validation",
+    "json",
+    "parse",
+    "domain"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": ">=22.18.0",
+      "onFail": "error"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepare": "npm run build",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test test/*.test.ts",
+    "compile-tests": "tsc -p tsconfig.runtime.json",
+    "catalog": "node scripts/catalog.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.5",
+    "typescript": "^5.9.0"
+  }
+}