@sdxc/structured-fields 0.0.0-pre.1

package/dist/schema.js

@@ -0,0 +1,181 @@
+import { createSchema, fail } from "remix/data-schema";
+import { Decimal, DisplayString, Token } from "./index.js";
+/** The largest magnitude an Integer may carry: fifteen nines. */
+const MAX_INTEGER = 999_999_999_999_999;
+/**
+ * Runs a nested schema at a path inside the field. A `remix/data-schema` schema runs with
+ * the path and options directly; any other Standard Schema has its issue paths prefixed.
+ *
+ * @param schema - The nested schema
+ * @param value - The nested value
+ * @param context - Where it sits
+ * @returns The nested result
+ */
+function run(schema, value, context) {
+    if ("~run" in schema && typeof schema["~run"] === "function") {
+        return schema["~run"](value, context);
+    }
+    let result = schema["~standard"].validate(value, context.options);
+    if (result instanceof Promise)
+        return fail("Schema must validate synchronously", context.path);
+    if (!result.issues)
+        return result;
+    return {
+        issues: result.issues.map((issue) => ({
+            ...issue,
+            path: [...context.path, ...(issue.path ?? [])],
+        })),
+    };
+}
+/**
+ * Builds the failure a helper reports for an input of the wrong type.
+ *
+ * @param message - What the helper expected
+ * @param code - The error-map code, so callers can localize the message
+ * @param value - The input
+ * @param context - Where it sits
+ * @returns The failure
+ */
+function reject(message, code, value, context) {
+    return fail(message, context.path, { code, input: value, parseOptions: context.options });
+}
+/**
+ * @param value - Any model value
+ * @returns Whether it is an Item, the member form without `items`
+ */
+function isItem(value) {
+    return typeof value === "object" && value !== null && "value" in value && !("items" in value);
+}
+/**
+ * @param value - Any model value
+ * @returns Whether it is an Inner List
+ */
+function isInnerList(value) {
+    return (typeof value === "object" && value !== null && "items" in value && Array.isArray(value.items));
+}
+/**
+ * Validates a member's parameters, passing them through when no schema is given.
+ *
+ * @param schema - The parameter schema, if any
+ * @param params - The member's parameters
+ * @param context - Where the member sits
+ * @returns The parameters' result
+ */
+function runParams(schema, params, context) {
+    let input = params ?? Object.create(null);
+    if (schema === undefined)
+        return { value: input };
+    return run(schema, input, { path: [...context.path, "params"], options: context.options });
+}
+/**
+ * The Structured Field schema builders. Each call returns a fresh schema, and none holds
+ * state, so a field's schema is built once at module scope and reused on every request.
+ *
+ * @example s.object({ u: s.optional(sf.value(sf.integer())) })
+ * @example sf.item(sf.token(), s.object({ ttl: s.optional(sf.integer()) }))
+ */
+export const sf = {
+    integer() {
+        return createSchema((value, context) => {
+            if (typeof value === "number" && Number.isInteger(value) && Math.abs(value) <= MAX_INTEGER) {
+                return { value };
+            }
+            return reject("Expected an Integer", "sf.integer", value, context);
+        });
+    },
+    decimal() {
+        return createSchema((value, context) => {
+            if (value instanceof Decimal)
+                return { value: value.value };
+            if (typeof value === "number" && Number.isFinite(value))
+                return { value };
+            return reject("Expected a Decimal", "sf.decimal", value, context);
+        });
+    },
+    token(allowed) {
+        return createSchema((value, context) => {
+            if (!(value instanceof Token))
+                return reject("Expected a Token", "sf.token", value, context);
+            if (allowed && !allowed.includes(value.value)) {
+                return fail(`Expected one of ${allowed.join(", ")}`, context.path, {
+                    code: "sf.token.allowed",
+                    input: value,
+                    values: { allowed: allowed.join(", ") },
+                    parseOptions: context.options,
+                });
+            }
+            return { value: value.value };
+        });
+    },
+    displayString() {
+        return createSchema((value, context) => {
+            if (value instanceof DisplayString)
+                return { value: value.value };
+            return reject("Expected a Display String", "sf.displayString", value, context);
+        });
+    },
+    bytes() {
+        return createSchema((value, context) => {
+            if (value instanceof Uint8Array)
+                return { value };
+            return reject("Expected a Byte Sequence", "sf.bytes", value, context);
+        });
+    },
+    date() {
+        return createSchema((value, context) => {
+            if (value instanceof Date)
+                return { value };
+            return reject("Expected a Date", "sf.date", value, context);
+        });
+    },
+    item(value, params) {
+        return createSchema((input, context) => {
+            if (!isItem(input))
+                return reject("Expected an Item", "sf.item", input, context);
+            let bare = run(value, input.value, {
+                path: [...context.path, "value"],
+                options: context.options,
+            });
+            let parameters = runParams(params, input.params, context);
+            if (bare.issues || parameters.issues) {
+                return { issues: [...(bare.issues ?? []), ...(parameters.issues ?? [])] };
+            }
+            return { value: { value: bare.value, params: parameters.value } };
+        });
+    },
+    value(value) {
+        return createSchema((input, context) => {
+            if (!isItem(input))
+                return reject("Expected an Item", "sf.item", input, context);
+            return run(value, input.value, {
+                path: [...context.path, "value"],
+                options: context.options,
+            });
+        });
+    },
+    innerList(item, params) {
+        return createSchema((input, context) => {
+            if (!isInnerList(input)) {
+                return reject("Expected an Inner List", "sf.innerList", input, context);
+            }
+            let issues = [];
+            let items = [];
+            input.items.forEach((member, index) => {
+                let result = run(item, member, {
+                    path: [...context.path, "items", index],
+                    options: context.options,
+                });
+                if (result.issues)
+                    issues.push(...result.issues);
+                else
+                    items.push(result.value);
+            });
+            let parameters = runParams(params, input.params, context);
+            if (parameters.issues)
+                issues.push(...parameters.issues);
+            if (issues.length > 0 || parameters.issues)
+                return { issues };
+            return { value: { items, params: parameters.value } };
+        });
+    },
+};

package/package.json

@@ -0,0 +1,25 @@
+{
+	"name": "@sdxc/structured-fields",
+	"version": "0.0.0-pre.1",
+	"description": "Parse and serialize RFC 9651 structured HTTP field values",
+	"license": "MIT",
+	"type": "module",
+	"exports": {
+		".": "./dist/index.js",
+		"./schema": "./dist/schema.js"
+	},
+	"dependencies": {
+		"@sdxc/result": "2026.9.15",
+		"@standard-schema/spec": "^1.1.0",
+		"remix": "3.0.0-rc.2"
+	},
+	"gitHead": "f0a77f407e4c30389df65cd8138b150e367da94f",
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/sergiodxa/monorepo.git",
+		"directory": "packages/structured-fields"
+	}
+}