@haiyue/ui 0.1.2 → 0.2.2

package/dist/portable/icons.js

@@ -0,0 +1,24 @@
+/** Public vector geometry. 24 × 24, 1.8 unit round strokes, no font or platform assets. */
+export const HY_ICONS = Object.freeze({
+    save: [[[4, 3], [17, 3], [21, 7], [21, 21], [3, 21], [3, 3], [4, 3]], [[7, 3], [7, 9], [17, 9], [17, 3]], [[7, 21], [7, 14], [17, 14], [17, 21]]],
+    export: [[[12, 15], [12, 3]], [[7, 8], [12, 3], [17, 8]], [[4, 14], [4, 21], [20, 21], [20, 14]]],
+    play: [[[7, 4], [20, 12], [7, 20], [7, 4]]], pause: [[[8, 4], [8, 20]], [[16, 4], [16, 20]]],
+    reset: [[[4, 9], [6, 5], [10, 3], [15, 3], [19, 6], [21, 10], [21, 14], [18, 19], [14, 21], [9, 20], [6, 17]], [[4, 3], [4, 9], [10, 9]]],
+    step: [[[5, 5], [15, 12], [5, 19], [5, 5]], [[19, 5], [19, 19]]],
+    settings: [[[19.438, 10.007], [21.848, 10.264], [21.848, 13.736], [19.438, 13.993], [18.668, 15.85], [20.192, 17.736], [17.736, 20.192], [15.85, 18.668], [13.993, 19.438], [13.736, 21.848], [10.264, 21.848], [10.007, 19.438], [8.15, 18.668], [6.264, 20.192], [3.808, 17.736], [5.332, 15.85], [4.562, 13.993], [2.152, 13.736], [2.152, 10.264], [4.562, 10.007], [5.332, 8.15], [3.808, 6.264], [6.264, 3.808], [8.15, 5.332], [10.007, 4.562], [10.264, 2.152], [13.736, 2.152], [13.993, 4.562], [15.85, 5.332], [17.736, 3.808], [20.192, 6.264], [18.668, 8.15], [19.438, 10.007]], [[15.0, 12.0], [14.942, 12.585], [14.772, 13.148], [14.494, 13.667], [14.121, 14.121], [13.667, 14.494], [13.148, 14.772], [12.585, 14.942], [12.0, 15.0], [11.415, 14.942], [10.852, 14.772], [10.333, 14.494], [9.879, 14.121], [9.506, 13.667], [9.228, 13.148], [9.058, 12.585], [9.0, 12.0], [9.058, 11.415], [9.228, 10.852], [9.506, 10.333], [9.879, 9.879], [10.333, 9.506], [10.852, 9.228], [11.415, 9.058], [12.0, 9.0], [12.585, 9.058], [13.148, 9.228], [13.667, 9.506], [14.121, 9.879], [14.494, 10.333], [14.772, 10.852], [14.942, 11.415], [15.0, 12.0]]],
+    back: [[[14, 4], [6, 12], [14, 20]], [[6, 12], [21, 12]]], chevronDown: [[[6, 9], [12, 15], [18, 9]]],
+    check: [[[4, 12], [9, 17], [20, 6]]], close: [[[6, 6], [18, 18]], [[18, 6], [6, 18]]], add: [[[12, 4], [12, 20]], [[4, 12], [20, 12]]],
+});
+for (const paths of Object.values(HY_ICONS)) {
+    for (const points of paths) {
+        for (const point of points)
+            Object.freeze(point);
+        Object.freeze(points);
+    }
+    Object.freeze(paths);
+}
+/** Safe SVG built only from the library's numeric paths. Color inherits from its host. */
+export function hyIconSvg(name) {
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${HY_ICONS[name].map(points => `<polyline points="${points.map(p => p.join(',')).join(' ')}"/>`).join('')}</svg>`;
+}
+//# sourceMappingURL=icons.js.map

package/dist/portable/index.d.ts

@@ -0,0 +1,7 @@
+export { HYPage } from './page.js';
+export type { HYPageOptions, HYPageStatus, HYBinding } from './page.js';
+export { HY_THEME_TOKENS, hyNativeTheme, hyThemeVariables } from './theme.js';
+export type { HYThemeVariables } from './theme.js';
+export { HY_ICONS, hyIconSvg } from './icons.js';
+export { hyResponsiveGrid, hyResponsiveWorkspace } from './responsive.js';
+export type { HYResponsiveGridOptions, HYResponsiveWorkspaceOptions } from './responsive.js';

package/dist/portable/index.js

@@ -0,0 +1,5 @@
+export { HYPage } from './page.js';
+export { HY_THEME_TOKENS, hyNativeTheme, hyThemeVariables } from './theme.js';
+export { HY_ICONS, hyIconSvg } from './icons.js';
+export { hyResponsiveGrid, hyResponsiveWorkspace } from './responsive.js';
+//# sourceMappingURL=index.js.map

package/dist/portable/page.d.ts

@@ -0,0 +1,38 @@
+import type { HYCapabilities, HYComponentKind, HYComponentProps, HYDispose, HYNode, HYReason, HYRenderer, HYStore, HYUIEvent } from '../core/types.js';
+export type HYPageStatus = 'new' | 'mounted' | 'suspended' | 'faulted' | 'disposed';
+export interface HYPageOptions {
+    readonly onEvent?: (event: HYUIEvent) => void;
+    /** Scoped key from hyKey(). If unavailable the root receives focus. */
+    readonly defaultFocus?: string;
+}
+export type HYBinding<S> = {
+    [K in HYComponentKind]: {
+        readonly key: string;
+        readonly kind: K;
+        readonly select: (state: Readonly<S>) => Readonly<HYComponentProps[K]>;
+        readonly equal?: (a: Readonly<HYComponentProps[K]>, b: Readonly<HYComponentProps[K]>) => boolean;
+    };
+}[HYComponentKind];
+/** A synchronous, bounded page reconciler. It owns bindings/rendering, never the application store. */
+export declare class HYPage {
+    #private;
+    private readonly options;
+    constructor(renderer: HYRenderer, options?: HYPageOptions);
+    get status(): HYPageStatus;
+    get revision(): number;
+    get capabilities(): HYCapabilities;
+    mount(root: HYNode): void;
+    render(root: HYNode): void;
+    setProps<K extends HYComponentKind>(key: string, kind: K, props: HYComponentProps[K]): void;
+    transaction(run: () => void): void;
+    /** One store subscription: a store transaction produces one final page batch across all bindings. */
+    bind<S, A>(store: HYStore<S, A>, bindings: readonly HYBinding<S>[]): HYDispose;
+    focus(key: string): boolean;
+    /** The shell chooses this single system-back owner. A modal consumes even a non-dismissible back. */
+    back(reason?: HYReason): boolean;
+    suspend(): void;
+    resume(): void;
+    /** Replaces the failed backend, preserving latest requested data and existing store bindings. */
+    rebuild(renderer: HYRenderer): void;
+    dispose(): void;
+}

package/dist/portable/page.js

@@ -0,0 +1,361 @@
+import { HYUIError, hyValidateCapabilities, hyValidateNode, hyValidateProps, snapshotValidatedProps } from '../core/validation.js';
+import { equalData, snapshot } from '../core/data.js';
+import { diff, flatten } from './tree.js';
+const interactive = new Set(['Button', 'Toggle', 'Select', 'Tabs', 'TextInput', 'TextArea', 'Slider', 'PlatformView']);
+/** A synchronous, bounded page reconciler. It owns bindings/rendering, never the application store. */
+export class HYPage {
+    options;
+    #renderer;
+    #capabilities;
+    #status = 'new';
+    #revision = 0;
+    #epoch = 0;
+    #depth = 0;
+    #committing = false;
+    #desired = new Map();
+    #rendered = new Map();
+    // Undefined means topology may have changed; otherwise only these props
+    // need comparison. Keep tree order deterministic across grouped updates.
+    #updates;
+    #order = new Map();
+    #subscriptions = new Set();
+    #focused;
+    #boundStores = new Set();
+    #openers = new Map();
+    #cancelTransaction = 0;
+    constructor(renderer, options = {}) {
+        this.options = options;
+        hyValidateCapabilities(renderer.capabilities);
+        this.#renderer = renderer;
+        this.#capabilities = snapshot(renderer.capabilities);
+    }
+    get status() { return this.#status; }
+    get revision() { return this.#revision; }
+    get capabilities() { return this.#capabilities; }
+    #assertMutable() {
+        if (this.#status === 'disposed' || this.#committing)
+            throw new HYUIError('lifecycle', 'Page disposed or inside renderer commit');
+    }
+    mount(root) {
+        if (this.#status !== 'new')
+            throw new HYUIError('lifecycle', 'Page may only mount once');
+        this.#desired = flatten(hyValidateNode(root, this.#capabilities));
+        this.#mountRenderer();
+        this.#flush();
+    }
+    #mountRenderer() {
+        const epoch = ++this.#epoch;
+        this.#committing = true;
+        try {
+            this.#renderer.mount(event => { if (epoch === this.#epoch)
+                this.#event(event); });
+            this.#status = 'mounted';
+        }
+        catch (cause) {
+            this.#fault(cause, 'mount');
+        }
+        finally {
+            this.#committing = false;
+        }
+    }
+    render(root) {
+        this.#assertMutable();
+        if (this.#status === 'new')
+            throw new HYUIError('lifecycle', 'Mount the page before render');
+        this.#desired = flatten(hyValidateNode(root, this.#capabilities));
+        this.#updates = undefined;
+        this.#flush();
+    }
+    setProps(key, kind, props) {
+        this.#assertMutable();
+        const entry = this.#desired.get(key);
+        if (!entry || entry.node.kind !== kind)
+            throw new HYUIError('invalid-props', 'Binding target missing or kind changed', { key });
+        const context = { key, ...(entry.node.source ? { source: entry.node.source } : {}) };
+        const accepted = snapshotValidatedProps(kind, props, context, this.#capabilities);
+        if (equalData(entry.node.props, props))
+            return;
+        const next = new Map(this.#desired);
+        next.set(key, { ...entry, node: Object.freeze({ ...entry.node, props: accepted }) });
+        this.#desired = next;
+        this.#updates?.add(key);
+        this.#flush();
+    }
+    transaction(run) {
+        this.#assertMutable();
+        const before = this.#desired, updates = this.#updates && new Set(this.#updates);
+        this.#depth++;
+        try {
+            const result = run();
+            if (result && typeof result.then === 'function')
+                throw new HYUIError('lifecycle', 'Page transactions must be synchronous');
+        }
+        catch (cause) {
+            this.#desired = before;
+            this.#updates = updates;
+            throw cause;
+        }
+        finally {
+            this.#depth--;
+        }
+        this.#flush();
+    }
+    /** One store subscription: a store transaction produces one final page batch across all bindings. */
+    bind(store, bindings) {
+        this.#assertMutable();
+        if (this.#boundStores.has(store))
+            throw new HYUIError('lifecycle', 'Group all bindings for one store in a single bind call');
+        const definitions = [...bindings];
+        if (new Set(definitions.map(b => b.key)).size !== definitions.length)
+            throw new HYUIError('duplicate-key', 'Duplicate binding target');
+        const select = (state) => definitions.map(b => b.select(state));
+        const equal = (a, b) => a.every((p, i) => (definitions[i].equal ?? equalData)(p, b[i]));
+        let applied = [];
+        const apply = (props) => {
+            if (this.#status === 'disposed')
+                return;
+            this.transaction(() => definitions.forEach((binding, i) => {
+                const node = this.#desired.get(binding.key)?.node;
+                // A grouped subscription does not make every binding dirty. Reuse a
+                // previously validated result only while its target is still unchanged.
+                // External render/setProps and failed transactions invalidate this path.
+                if (node === applied[i] && node && equalData(node.props, props[i]))
+                    return;
+                this.setProps(binding.key, binding.kind, props[i]);
+            }));
+            applied = definitions.map(binding => this.#desired.get(binding.key)?.node);
+        };
+        apply(select(store.getSnapshot()));
+        let live = true;
+        const unsubscribe = store.subscribe(select, values => { if (live)
+            apply(values); }, equal);
+        const dispose = () => { if (!live)
+            return; live = false; this.#subscriptions.delete(dispose); this.#boundStores.delete(store); unsubscribe(); };
+        this.#boundStores.add(store);
+        this.#subscriptions.add(dispose);
+        // Also captures synchronous changes caused by mount/update hooks before subscription began.
+        try {
+            apply(select(store.getSnapshot()));
+        }
+        catch (cause) {
+            dispose();
+            throw cause;
+        }
+        return dispose;
+    }
+    #fault(cause, operation, key) {
+        this.#status = 'faulted';
+        const context = cause instanceof HYUIError ? cause.context : {};
+        throw new HYUIError('renderer', 'Renderer failed; rebuild required', {
+            key: key ?? this.#desired.keys().next().value ?? '<root>', operation, ...context,
+            revision: operation === 'commit' || operation === 'mount' ? this.#revision + 1 : this.#revision,
+        }, cause);
+    }
+    #flush() {
+        if (this.#depth || this.#status !== 'mounted' || this.#committing)
+            return;
+        const next = this.#desired, previous = this.#rendered;
+        if (next === previous)
+            return;
+        const topology = this.#updates === undefined;
+        const mutations = topology ? diff(previous, next)
+            : Object.freeze([...this.#updates].sort((a, b) => this.#order.get(a) - this.#order.get(b)).flatMap(key => {
+                const node = next.get(key).node;
+                return equalData(previous.get(key).node.props, node.props) ? [] : [Object.freeze({ type: 'update', node })];
+            }));
+        const focusChanged = topology || mutations.some(m => {
+            if (m.type !== 'update')
+                return true;
+            const a = previous.get(m.node.key).node.props, b = m.node.props;
+            return a.visible !== b.visible || ('disabled' in a && a.disabled) !== ('disabled' in b && b.disabled)
+                || ('busy' in a && a.busy) !== ('busy' in b && b.busy)
+                || (m.node.kind === 'Dialog' && ('open' in a && a.open) !== m.node.props.open)
+                || (m.node.kind === 'Tabs' && ('value' in a && a.value) !== m.node.props.value);
+        });
+        if (!mutations.length) {
+            this.#rendered = next;
+            this.#updates = new Set();
+            return;
+        }
+        this.#committing = true;
+        try {
+            this.#renderer.commit(this.#revision + 1, mutations);
+        }
+        catch (cause) {
+            this.#fault(cause, 'commit');
+        }
+        finally {
+            this.#committing = false;
+        }
+        this.#rendered = next;
+        this.#revision++;
+        this.#updates = new Set();
+        if (topology)
+            this.#order = new Map([...next.keys()].map((key, index) => [key, index]));
+        if (focusChanged)
+            this.#restoreFocus(previous);
+    }
+    #available(key, tree = this.#rendered) {
+        if (!key)
+            return false;
+        let entry = tree.get(key);
+        if (!entry)
+            return false;
+        while (entry) {
+            const p = entry.node.props;
+            if (p.visible === false || ('disabled' in p && p.disabled) || ('busy' in p && p.busy) || (entry.node.kind === 'Dialog' && !entry.node.props.open))
+                return false;
+            const parent = entry.parent === null ? undefined : tree.get(entry.parent);
+            if (parent?.node.kind === 'Tabs' && entry.slot !== parent.node.props.value)
+                return false;
+            entry = parent;
+        }
+        return true;
+    }
+    #dialogs(tree) {
+        return [...tree].filter(([key, entry]) => entry.node.kind === 'Dialog' && entry.node.props.open && this.#available(key, tree)).map(([key]) => key);
+    }
+    #inside(key, parent) { return key === parent || key.startsWith(`${parent}/`); }
+    #dialogTarget(key) {
+        return [...this.#rendered].find(([id, entry]) => this.#inside(id, key) && interactive.has(entry.node.kind) && this.#available(id))?.[0] ?? key;
+    }
+    #restoreFocus(previous) {
+        const oldDialogs = this.#dialogs(previous), dialogs = this.#dialogs(this.#rendered);
+        const newDialogs = dialogs.filter(key => !oldDialogs.includes(key));
+        for (const key of newDialogs)
+            this.#openers.set(key, this.#focused);
+        const top = dialogs.at(-1);
+        const closed = oldDialogs.filter(key => !dialogs.includes(key));
+        if (newDialogs.length || (top && (!this.#focused || !this.#inside(this.#focused, top))))
+            this.focus(this.#dialogTarget(top));
+        else if (this.#focused && !this.#available(this.#focused)) {
+            const opener = closed.slice().reverse().map(key => this.#openers.get(key)).find(key => this.#available(key));
+            const target = top ? this.#dialogTarget(top) : opener ?? (this.#available(this.options.defaultFocus) ? this.options.defaultFocus : this.#rendered.keys().next().value);
+            if (target)
+                this.focus(target);
+            else
+                this.#focused = undefined;
+        }
+        for (const key of closed)
+            this.#openers.delete(key);
+    }
+    focus(key) {
+        if (this.#status !== 'mounted' || this.#committing || !this.#available(key))
+            return false;
+        const top = this.#dialogs(this.#rendered).at(-1);
+        if (top && !this.#inside(key, top))
+            return false;
+        this.#committing = true;
+        try {
+            this.#renderer.focus(key);
+            this.#focused = key;
+        }
+        catch (cause) {
+            this.#fault(cause, 'focus', key);
+        }
+        finally {
+            this.#committing = false;
+        }
+        return true;
+    }
+    #event(event) {
+        if (this.#committing || this.#status !== 'mounted' || !this.#available(event.key))
+            return;
+        const top = this.#dialogs(this.#rendered).at(-1);
+        if (top && !this.#inside(event.key, top))
+            return;
+        if (event.type === 'focus')
+            this.#focused = event.key;
+        this.options.onEvent?.(Object.freeze({ ...event }));
+    }
+    /** The shell chooses this single system-back owner. A modal consumes even a non-dismissible back. */
+    back(reason = 'keyboard') {
+        if (this.#status !== 'mounted' || this.#committing)
+            return false;
+        const key = this.#dialogs(this.#rendered).at(-1);
+        if (!key)
+            return false;
+        const node = this.#rendered.get(key).node;
+        if (node.kind === 'Dialog' && node.props.dismissible !== false)
+            this.#event({ key, type: 'cancel', reason, transaction: ++this.#cancelTransaction });
+        return true;
+    }
+    suspend() {
+        if (this.#status !== 'mounted' || this.#committing)
+            return;
+        this.#status = 'suspended';
+        try {
+            this.#renderer.suspend();
+        }
+        catch (cause) {
+            this.#fault(cause, 'suspend');
+        }
+    }
+    resume() {
+        if (this.#status !== 'suspended')
+            return;
+        try {
+            this.#renderer.resume();
+        }
+        catch (cause) {
+            this.#fault(cause, 'resume');
+        }
+        this.#status = 'mounted';
+        this.#flush();
+    }
+    /** Replaces the failed backend, preserving latest requested data and existing store bindings. */
+    rebuild(renderer) {
+        if (this.#status !== 'faulted')
+            throw new HYUIError('lifecycle', 'Only a faulted page may rebuild');
+        if (renderer === this.#renderer)
+            throw new HYUIError('lifecycle', 'Rebuild needs a fresh renderer');
+        hyValidateCapabilities(renderer.capabilities);
+        for (const [key, entry] of this.#desired) {
+            hyValidateProps(entry.node.kind, entry.node.props, { key }, renderer.capabilities);
+            for (const feature of entry.node.requires ?? [])
+                if (!renderer.capabilities.features.includes(feature))
+                    throw new HYUIError('capability', `Missing capability ${feature}`, { key });
+        }
+        ++this.#epoch;
+        this.#renderer.dispose();
+        this.#renderer = renderer;
+        this.#capabilities = snapshot(renderer.capabilities);
+        this.#rendered = new Map();
+        this.#updates = undefined;
+        this.#order.clear();
+        this.#focused = undefined;
+        this.#openers.clear();
+        this.#mountRenderer();
+        this.#flush();
+    }
+    dispose() {
+        if (this.#status === 'disposed')
+            return;
+        this.#status = 'disposed';
+        ++this.#epoch;
+        const errors = [];
+        for (const unsubscribe of this.#subscriptions)
+            try {
+                unsubscribe();
+            }
+            catch (cause) {
+                errors.push(cause);
+            }
+        this.#subscriptions.clear();
+        try {
+            this.#renderer.dispose();
+        }
+        catch (cause) {
+            errors.push(cause);
+        }
+        this.#updates = undefined;
+        this.#order.clear();
+        this.#desired = new Map();
+        this.#rendered = new Map();
+        this.#openers.clear();
+        this.#focused = undefined;
+        if (errors.length)
+            throw new AggregateError(errors, 'Page cleanup failed');
+    }
+}
+//# sourceMappingURL=page.js.map

package/dist/portable/responsive.d.ts

@@ -0,0 +1,20 @@
+/** Platform-independent logical-pixel layout decisions. */
+export interface HYResponsiveGridOptions {
+    readonly minCardWidth?: number;
+    readonly maxColumns?: number;
+    readonly gap?: number;
+}
+export declare function hyResponsiveGrid(width: number, options?: HYResponsiveGridOptions): Readonly<{
+    columns: number;
+    gap: number;
+    cardWidth: number;
+}>;
+export interface HYResponsiveWorkspaceOptions {
+    readonly minPaneWidth?: number;
+    readonly gap?: number;
+}
+export declare function hyResponsiveWorkspace(width: number, height: number, options?: HYResponsiveWorkspaceOptions): Readonly<{
+    split: boolean;
+    gap: number;
+    referenceHeight: number;
+}>;

package/dist/portable/responsive.js

@@ -0,0 +1,15 @@
+export function hyResponsiveGrid(width, options = {}) {
+    const { minCardWidth = 260, maxColumns = 4, gap = 16 } = options;
+    if (!Number.isFinite(width) || width < 0 || !Number.isFinite(minCardWidth) || minCardWidth <= 0 || !Number.isInteger(maxColumns) || maxColumns < 1 || !Number.isFinite(gap) || gap < 0)
+        throw new RangeError('Invalid responsive grid dimensions');
+    const columns = Math.max(1, Math.min(maxColumns, Math.floor((width + gap) / (minCardWidth + gap))));
+    return Object.freeze({ columns, gap, cardWidth: Math.max(0, (width - gap * (columns - 1)) / columns) });
+}
+export function hyResponsiveWorkspace(width, height, options = {}) {
+    const { minPaneWidth = 420, gap = 16 } = options;
+    if (![width, height, gap].every(v => Number.isFinite(v) && v >= 0) || !Number.isFinite(minPaneWidth) || minPaneWidth <= 0)
+        throw new RangeError('Invalid responsive workspace dimensions');
+    const split = width >= minPaneWidth * 2 + gap && height >= 420;
+    return Object.freeze({ split, gap, referenceHeight: Math.min(280, Math.max(0, height - 120), Math.max(120, Math.round(height * .38))) });
+}
+//# sourceMappingURL=responsive.js.map

package/dist/portable/theme.d.ts

@@ -0,0 +1,24 @@
+import type { HYTheme } from '../core/types.js';
+export declare const HY_THEME_TOKENS: Readonly<{
+    readonly text: "--hy-text-color";
+    readonly muted: "--hy-secondary-text-color";
+    readonly surface: "--hy-surface-color";
+    readonly input: "--hy-input-bg-color";
+    readonly accent: "--hy-accent-color";
+    readonly danger: "--hy-invalid-border-color";
+    readonly border: "--hy-border-color";
+    readonly focus: "--hy-focus-ring-color";
+    readonly selected: "--hy-selected-bg-color";
+    readonly pressed: "--hy-pressed-bg-color";
+    readonly disabled: "--hy-disabled-text-color";
+    readonly elevated: "--hy-surface-elevated-color";
+    readonly onAccent: "--hy-on-accent-color";
+    readonly fontSize: "--hy-font-size";
+    readonly lineHeight: "--hy-line-height";
+    readonly gap: "--hy-gap";
+    readonly radius: "--hy-radius";
+}>;
+export type HYThemeVariables = Readonly<Record<(typeof HY_THEME_TOKENS)['text' | 'muted' | 'surface' | 'input' | 'accent' | 'danger' | 'border' | 'focus' | 'fontSize' | 'lineHeight' | 'gap' | 'radius'], string> & Partial<Record<(typeof HY_THEME_TOKENS)[keyof typeof HY_THEME_TOKENS], string>> & Record<string, string>>;
+export declare function hyNativeTheme(theme: HYTheme, fontScale?: number): HYTheme;
+/** Returns data for an adapter to apply; importing it never creates a stylesheet. */
+export declare function hyThemeVariables(theme: HYTheme, fontScale?: number): HYThemeVariables;

package/dist/portable/theme.js

@@ -0,0 +1,60 @@
+import { HYUIError } from '../core/validation.js';
+import { snapshot } from '../core/data.js';
+export const HY_THEME_TOKENS = Object.freeze({
+    text: '--hy-text-color', muted: '--hy-secondary-text-color', surface: '--hy-surface-color', input: '--hy-input-bg-color',
+    accent: '--hy-accent-color', danger: '--hy-invalid-border-color', border: '--hy-border-color', focus: '--hy-focus-ring-color',
+    selected: '--hy-selected-bg-color', pressed: '--hy-pressed-bg-color', disabled: '--hy-disabled-text-color', elevated: '--hy-surface-elevated-color', onAccent: '--hy-on-accent-color',
+    fontSize: '--hy-font-size', lineHeight: '--hy-line-height', gap: '--hy-gap', radius: '--hy-radius',
+});
+export function hyNativeTheme(theme, fontScale = 1) {
+    const bad = (property) => { throw new HYUIError('invalid-props', 'Invalid portable theme value', { property }); };
+    if (!theme || typeof theme !== 'object')
+        bad('theme');
+    for (const key of Object.keys(theme))
+        if (!['color', 'fontSize', 'lineHeight', 'gap', 'radius', 'typography'].includes(key))
+            bad(key);
+    if (!Number.isFinite(fontScale) || fontScale <= 0)
+        bad('fontScale');
+    for (const key of ['fontSize', 'lineHeight', 'gap', 'radius']) {
+        if (!Number.isFinite(theme[key]) || theme[key] < 0 || ((key === 'fontSize' || key === 'lineHeight') && theme[key] === 0))
+            bad(key);
+    }
+    for (const key of ['text', 'muted', 'surface', 'input', 'accent', 'danger', 'border', 'focus']) {
+        if (typeof theme.color?.[key] !== 'string' || !/^#[\da-f]{6}([\da-f]{2})?$/i.test(theme.color[key]))
+            bad(`color.${key}`);
+    }
+    for (const key of Object.keys(theme.color))
+        if (!['text', 'muted', 'surface', 'input', 'accent', 'danger', 'border', 'focus', 'selected', 'pressed', 'disabled', 'elevated', 'onAccent'].includes(key))
+            bad(`color.${key}`);
+    for (const [key, value] of Object.entries(theme.color))
+        if (typeof value !== 'string' || !/^#[\da-f]{6}([\da-f]{2})?$/i.test(value))
+            bad(`color.${key}`);
+    const typography = {};
+    if (theme.typography !== undefined) {
+        if (!theme.typography || typeof theme.typography !== 'object' || Array.isArray(theme.typography))
+            bad('typography');
+        for (const [key, value] of Object.entries(theme.typography)) {
+            if (!['title', 'body', 'caption'].includes(key) || !value || typeof value !== 'object')
+                bad(`typography.${key}`);
+            for (const field of Object.keys(value))
+                if (!['fontSize', 'lineHeight', 'weight'].includes(field))
+                    bad(`typography.${key}.${field}`);
+            if (![value.fontSize, value.lineHeight].every(v => Number.isFinite(v) && v > 0 && Number.isFinite(v * fontScale)) || (value.weight !== undefined && !['normal', 'medium', 'bold'].includes(value.weight)))
+                bad(`typography.${key}`);
+            typography[key] = { ...value, fontSize: value.fontSize * fontScale, lineHeight: value.lineHeight * fontScale };
+        }
+    }
+    if (!Number.isFinite(theme.fontSize * fontScale) || !Number.isFinite(theme.lineHeight * fontScale))
+        bad('fontScale');
+    return snapshot({ color: { ...theme.color }, fontSize: theme.fontSize * fontScale, lineHeight: theme.lineHeight * fontScale, gap: theme.gap, radius: theme.radius, ...(theme.typography ? { typography } : {}) });
+}
+/** Returns data for an adapter to apply; importing it never creates a stylesheet. */
+export function hyThemeVariables(theme, fontScale = 1) {
+    const data = hyNativeTheme(theme, fontScale);
+    return Object.freeze(Object.fromEntries([
+        ...Object.entries(data.color).map(([key, value]) => [HY_THEME_TOKENS[key], value]),
+        ...['fontSize', 'lineHeight', 'gap', 'radius'].map(key => [HY_THEME_TOKENS[key], `${data[key]}px`]),
+        ...Object.entries(data.typography ?? {}).flatMap(([key, value]) => [[`--hy-${key}-font-size`, `${value.fontSize}px`], [`--hy-${key}-line-height`, `${value.lineHeight}px`], [`--hy-${key}-font-weight`, value.weight === 'bold' ? '700' : value.weight === 'medium' ? '500' : '400']]),
+    ]));
+}
+//# sourceMappingURL=theme.js.map

package/dist/portable/tree.d.ts

@@ -0,0 +1,10 @@
+import type { HYMutation, HYNode } from '../core/types.js';
+export interface Entry {
+    readonly node: HYNode;
+    readonly parent: string | null;
+    readonly slot?: string;
+}
+export type Tree = ReadonlyMap<string, Entry>;
+export declare function flatten(root: HYNode): Tree;
+/** Returns a deterministic batch. Removing an ancestor releases descendants exactly once. */
+export declare function diff(previous: Tree, next: Tree): readonly HYMutation[];