@uicast/core 0.0.1-beta.2 → 0.0.1

package/dist/prompt-utils/json-schema-to-ts.d.ts

@@ -1,73 +0,0 @@
-type JSONSchemaType = "object" | "array" | "string" | "number" | "boolean" | "null" | "integer";
-/**
- * JSON Schema shape this module reads — a recursive structural type covering
- * the draft-07 / 2020-12 keywords a Standard-Schema `toJSONSchema()` can emit
- * (primitives, composition, objects, arrays/tuples, `$ref` + `$defs`, and the
- * refinement keywords that constrain a value without changing its TypeScript
- * type). Every sub-schema slot is another `JSONSchema`.
- *
- * `JSONSchemaToTs` still takes `unknown` and narrows at runtime, because a
- * schema value can also be a boolean (`true`/`false`) — and, in legacy
- * draft-07, an `items` array — which this object type intentionally doesn't
- * model. The function reads back through itself, so the recursion stays loose.
- */
-export interface JSONSchema {
-    $schema?: "https://json-schema.org/draft/2020-12/schema" | "http://json-schema.org/draft-07/schema#";
-    type?: JSONSchemaType | JSONSchemaType[];
-    format?: string;
-    pattern?: string;
-    $ref?: string;
-    items?: boolean | JSONSchema;
-    prefixItems?: JSONSchema[];
-    additionalItems?: boolean | JSONSchema;
-    enum?: unknown[];
-    minimum?: number;
-    maximum?: number;
-    exclusiveMinimum?: number;
-    exclusiveMaximum?: number;
-    minItems?: number;
-    maxItems?: number;
-    title?: string;
-    description?: string;
-    properties?: {
-        [key: string]: JSONSchema;
-    };
-    required?: string[];
-    examples?: unknown[];
-    not?: JSONSchema;
-    $defs?: {
-        [key: string]: JSONSchema;
-    };
-    definitions?: {
-        [key: string]: JSONSchema;
-    };
-    additionalProperties?: boolean | JSONSchema;
-    anyOf?: JSONSchema[];
-    oneOf?: JSONSchema[];
-    allOf?: JSONSchema[];
-    const?: unknown;
-    example?: unknown;
-    contentEncoding?: string;
-    contentMediaType?: string;
-    minLength?: number;
-    maxLength?: number;
-    "x-tsType"?: string;
-}
-export type JSONSchemaToTsOptions = {
-    /**
-     * Render objects one property per line, indented. The string is the prefix
-     * every generated line starts with (the caller's continuation indent, e.g.
-     * `"  "` inside a Markdown bullet); nesting adds two spaces per level.
-     * Omit for the compact single-line form.
-     */
-    multiline?: string;
-};
-/**
- * Convert a JSON Schema to a compact TypeScript type string for the prompt.
- *
- * Pass the whole schema document (with any `$defs` / `definitions`): local
- * `$ref`s resolve against it, and a recursive schema terminates — the cycle's
- * back-edge renders as `unknown` while everything above it stays fully typed.
- */
-export declare function JSONSchemaToTs(jsonSchema: unknown, options?: JSONSchemaToTsOptions): string;
-export {};

package/dist/prompt-utils/json-schema-to-ts.js

@@ -1,199 +0,0 @@
-/**
- * Convert a JSON Schema to a compact TypeScript type string for the prompt.
- *
- * Pass the whole schema document (with any `$defs` / `definitions`): local
- * `$ref`s resolve against it, and a recursive schema terminates — the cycle's
- * back-edge renders as `unknown` while everything above it stays fully typed.
- */
-export function JSONSchemaToTs(jsonSchema, options) {
-    const ml = (options === null || options === void 0 ? void 0 : options.multiline) !== undefined
-        ? { pad: options.multiline, depth: 0 }
-        : null;
-    return toTs(jsonSchema, jsonSchema, new Set(), ml);
-}
-/**
- * Recursive worker. Renders the node's type, then — when the node carries a
- * `description` — appends it as a trailing ` /* … *​/` comment, so per-field
- * docs (Zod `.describe()` / `.meta({ description })`) survive into the prompt
- * at every nesting level. Nodes without a description add nothing.
- */
-function toTs(jsonSchema, root, seen, ml = null) {
-    var _a;
-    const base = toTsBase(jsonSchema, root, seen, ml);
-    if (jsonSchema !== null &&
-        typeof jsonSchema === "object" &&
-        typeof jsonSchema.description === "string") {
-        // One line, and never a premature close: `*/` inside a description
-        // would truncate the comment (and the type after it).
-        const description = (_a = jsonSchema.description) === null || _a === void 0 ? void 0 : _a.replace(/\s+/g, " ").replace(/\*\//g, "*").trim();
-        if (description)
-            return `${base} /* ${description} */`;
-    }
-    return base;
-}
-/**
- * Type rendering without the description pass. `root` is the document the
- * first call was handed (the resolution base for `$ref`); `seen` is the set of
- * refs currently being expanded on this path, so a cycle short-circuits to
- * `unknown` instead of recursing forever.
- */
-function toTsBase(jsonSchema, root, seen, ml) {
-    if (jsonSchema === true)
-        return "unknown";
-    if (jsonSchema === false)
-        return "never";
-    if (jsonSchema === null || jsonSchema === undefined)
-        return "unknown";
-    if (typeof jsonSchema !== "object")
-        return "unknown";
-    const schema = jsonSchema;
-    if (typeof schema.$ref === "string") {
-        if (seen.has(schema.$ref))
-            return "unknown"; // cycle back-edge
-        const target = resolveRef(schema.$ref, root);
-        if (target === undefined)
-            return "unknown";
-        seen.add(schema.$ref);
-        // When the referencing node has its own description, it wins (it names
-        // the field's role at THIS use site) — render the target without its
-        // root annotation so the field isn't double-commented. The target's
-        // nested fields keep their own annotations either way.
-        const resolved = typeof schema.description === "string"
-            ? toTsBase(target, root, seen, ml)
-            : toTs(target, root, seen, ml);
-        seen.delete(schema.$ref);
-        return resolved;
-    }
-    if ("const" in schema)
-        return JSON.stringify(schema.const);
-    if (schema.enum) {
-        return schema.enum.map((v) => JSON.stringify(v)).join(" | ") || "never";
-    }
-    if (schema.allOf) {
-        const parts = schema.allOf.map((s) => toTs(s, root, seen, ml));
-        return parts.length ? `(${parts.join(" & ")})` : "unknown";
-    }
-    if (schema.anyOf) {
-        const parts = schema.anyOf.map((s) => toTs(s, root, seen, ml));
-        return parts.length ? `(${parts.join(" | ")})` : "never";
-    }
-    if (schema.oneOf) {
-        const parts = schema.oneOf.map((s) => toTs(s, root, seen, ml));
-        return parts.length ? `(${parts.join(" | ")})` : "never";
-    }
-    if (schema.not)
-        return "unknown";
-    if (Array.isArray(schema.type)) {
-        // Drop the description on the per-type variants — the wrapper already
-        // annotates the union as a whole; keeping it would stamp every member.
-        const types = schema.type.map((t) => toTs(Object.assign(Object.assign({}, schema), { type: t, description: undefined }), root, seen, ml));
-        return types.length ? `(${types.join(" | ")})` : "unknown";
-    }
-    const type = schema.type;
-    if (type === "string")
-        return "string";
-    if (type === "number" || type === "integer")
-        return "number";
-    if (type === "boolean")
-        return "boolean";
-    if (type === "null")
-        return "null";
-    if (type === "object" ||
-        schema.properties ||
-        schema.additionalProperties !== undefined) {
-        const props = schema.properties || {};
-        const required = schema.required || [];
-        const childMl = ml ? { pad: ml.pad, depth: ml.depth + 1 } : null;
-        const propStrings = Object.entries(props).map(([key, value]) => {
-            const isRequired = required.includes(key);
-            const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)
-                ? key
-                : JSON.stringify(key);
-            return `${safeName}${isRequired ? "" : "?"}: ${toTs(value, root, seen, childMl)}`;
-        });
-        let additionalType = null;
-        if (schema.additionalProperties === true) {
-            additionalType = "unknown";
-        }
-        else if (schema.additionalProperties &&
-            typeof schema.additionalProperties === "object") {
-            additionalType = toTs(schema.additionalProperties, root, seen);
-        }
-        if (propStrings.length === 0 && additionalType) {
-            return `{ [key: string]: ${additionalType} }`;
-        }
-        if (propStrings.length === 0 && !additionalType) {
-            return schema.additionalProperties === false
-                ? "{}"
-                : "{ [key: string]: unknown }";
-        }
-        let result;
-        if (ml) {
-            // One property per line: fields one level deeper than this object's
-            // braces, the closing brace back at the object's own level.
-            const inner = ml.pad + "  ".repeat(ml.depth + 1);
-            const closing = ml.pad + "  ".repeat(ml.depth);
-            result = `{\n${inner}${propStrings.join(`;\n${inner}`)};\n${closing}}`;
-        }
-        else {
-            result = `{ ${propStrings.join("; ")} }`;
-        }
-        if (additionalType) {
-            result = `(${result} & { [key: string]: ${additionalType} })`;
-        }
-        return result;
-    }
-    if (type === "array" || schema.items || schema.prefixItems) {
-        if (schema.prefixItems) {
-            const tupleTypes = schema.prefixItems.map((s) => toTs(s, root, seen));
-            if (schema.items === false)
-                return `[${tupleTypes.join(", ")}]`;
-            const restType = schema.items ? toTs(schema.items, root, seen) : "unknown";
-            return `[${tupleTypes.join(", ")}, ...${restType}[]]`;
-        }
-        if (schema.items !== undefined && schema.items !== null) {
-            if (Array.isArray(schema.items)) {
-                const tupleTypes = schema.items.map((s) => toTs(s, root, seen));
-                if (schema.additionalItems === false) {
-                    return `[${tupleTypes.join(", ")}]`;
-                }
-                const restType = schema.additionalItems
-                    ? toTs(schema.additionalItems, root, seen)
-                    : "unknown";
-                return `[${tupleTypes.join(", ")}, ...${restType}[]]`;
-            }
-            const itemTs = toTs(schema.items, root, seen, ml);
-            // An item type ENDING in an annotation must be parenthesized —
-            // `string /* x */[]` reads as if the comment interrupts the type;
-            // `(string /* x */)[]` keeps the array suffix unambiguous. A comment
-            // safely inside braces (`{ a: string /* x */ }[]`) needs nothing.
-            return itemTs.endsWith("*/") ? `(${itemTs})[]` : `${itemTs}[]`;
-        }
-        return "unknown[]";
-    }
-    if (schema.properties) {
-        return toTs(Object.assign(Object.assign({}, schema), { type: "object" }), root, seen);
-    }
-    return "unknown";
-}
-/**
- * Resolve a local JSON Pointer ref (`#/$defs/Foo`, `#/definitions/Bar`)
- * against the document root. Returns the target sub-schema, or `undefined`
- * for a non-local ref (`https://…`, bare `#`) or a path that doesn't exist —
- * the caller renders those as `unknown`.
- */
-function resolveRef(ref, root) {
-    if (!ref.startsWith("#/"))
-        return undefined;
-    const segments = ref
-        .slice(2)
-        .split("/")
-        .map((seg) => seg.replace(/~1/g, "/").replace(/~0/g, "~"));
-    let node = root;
-    for (const seg of segments) {
-        if (node === null || typeof node !== "object")
-            return undefined;
-        node = node[seg];
-    }
-    return node;
-}

package/dist/stream/stream-json-lines.d.ts

@@ -1 +0,0 @@
-export declare function streamJsonLines<T = unknown>(source: ReadableStream<Uint8Array | string> | AsyncIterable<string | Uint8Array>): AsyncGenerator<T>;

package/dist/stream/stream-json-lines.js

@@ -1,94 +0,0 @@
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
-};
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
-// Yields every parseable JSON value from a byte or string stream, skipping
-// blank/non-JSON lines (code fences, model prose, partial lines). Narrow the
-// element type via <T>; shape-checking is the caller's concern.
-export function streamJsonLines(source) {
-    return __asyncGenerator(this, arguments, function* streamJsonLines_1() {
-        var _a, e_1, _b, _c;
-        const decoder = new TextDecoder();
-        let buffer = "";
-        try {
-            for (var _d = true, _e = __asyncValues(toAsyncIterable(source)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
-                _c = _f.value;
-                _d = false;
-                const chunk = _c;
-                buffer += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
-                let nl = buffer.indexOf("\n");
-                while (nl !== -1) {
-                    yield __await(yield* __asyncDelegator(__asyncValues(parseLine(buffer.slice(0, nl)))));
-                    buffer = buffer.slice(nl + 1);
-                    nl = buffer.indexOf("\n");
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        yield __await(yield* __asyncDelegator(__asyncValues(parseLine(buffer + decoder.decode()))));
-    });
-}
-function* parseLine(raw) {
-    const line = raw.trim();
-    if (!line)
-        return;
-    try {
-        yield JSON.parse(line);
-    }
-    catch (_a) {
-        // non-JSON noise (fences, prose, partial) — drop it
-    }
-}
-function toAsyncIterable(source) {
-    if (Symbol.asyncIterator in source) {
-        return source;
-    }
-    // Browser ReadableStream isn't async-iterable — pull it through a reader.
-    const stream = source;
-    return {
-        [Symbol.asyncIterator]() {
-            return __asyncGenerator(this, arguments, function* _a() {
-                const reader = stream.getReader();
-                try {
-                    for (;;) {
-                        const { done, value } = yield __await(reader.read());
-                        if (done)
-                            return yield __await(void 0);
-                        if (value !== undefined)
-                            yield yield __await(value);
-                    }
-                }
-                finally {
-                    reader.releaseLock();
-                }
-            });
-        },
-    };
-}

package/dist/utils/utils.d.ts

@@ -1,13 +0,0 @@
-import type { ComponentEntry } from "../types.js";
-/**
- * Build an elements-by-key map from the NDJSON lines array.
- *
- * When an entry with a duplicate key is encountered (i.e. the LLM re-emits a
- * entry to correct a mistake), the old subtree is removed before inserting
- * the replacement — except old nodes the new `children` array still
- * references (directly or through a kept child), which survive with their
- * own subtrees. This lets the LLM restructure a parent by re-emitting just
- * that entry, keeping existing children by reference, without regenerating
- * the entire tree.
- */
-export declare function buildElementsById(lines: ComponentEntry[]): Record<string, ComponentEntry>;

package/dist/utils/utils.js

@@ -1,58 +0,0 @@
-/**
- * Collect all descendant IDs of a given entry (not including the entry itself)
- * by walking its children array recursively.
- */
-function collectDescendantIds(id, map) {
-    const result = new Set();
-    const stack = [id];
-    while (stack.length > 0) {
-        const current = stack.pop();
-        const entry = map[current];
-        if (entry === null || entry === void 0 ? void 0 : entry.children) {
-            for (const childId of entry.children) {
-                if (!result.has(childId)) {
-                    result.add(childId);
-                    stack.push(childId);
-                }
-            }
-        }
-    }
-    return result;
-}
-/**
- * Build an elements-by-key map from the NDJSON lines array.
- *
- * When an entry with a duplicate key is encountered (i.e. the LLM re-emits a
- * entry to correct a mistake), the old subtree is removed before inserting
- * the replacement — except old nodes the new `children` array still
- * references (directly or through a kept child), which survive with their
- * own subtrees. This lets the LLM restructure a parent by re-emitting just
- * that entry, keeping existing children by reference, without regenerating
- * the entire tree.
- */
-export function buildElementsById(lines) {
-    var _a;
-    const map = {};
-    for (const line of lines) {
-        if (map[line.key]) {
-            const oldDescendants = collectDescendantIds(line.key, map);
-            const kept = new Set();
-            const stack = [...((_a = line.children) !== null && _a !== void 0 ? _a : [])];
-            while (stack.length > 0) {
-                const id = stack.pop();
-                if (kept.has(id) || !oldDescendants.has(id))
-                    continue;
-                kept.add(id);
-                const entry = map[id];
-                if (entry === null || entry === void 0 ? void 0 : entry.children)
-                    stack.push(...entry.children);
-            }
-            for (const descId of oldDescendants) {
-                if (!kept.has(descId))
-                    delete map[descId];
-            }
-        }
-        map[line.key] = line;
-    }
-    return map;
-}