@dixy-ui/themes 0.0.0-stage → 0.1.0-beta.1

package/dist/organic-css.d.ts

@@ -0,0 +1,3 @@
+import type { ThemeDocument } from "./theme-schema.ts";
+/** Portable numeric CSS controls; the optional renderer never executes imported data. */
+export declare function organicOrnamentVariables(frame: string, settings: ThemeDocument["recipes"]["frame"]["ornament"]): Record<string, string>;

package/dist/organic-css.js

@@ -0,0 +1,23 @@
+import { canopyShapes, stemCharacters, organicFrameRecipes, isOrganicFrame, } from "./organic-settings.js";
+/** Portable numeric CSS controls; the optional renderer never executes imported data. */
+export function organicOrnamentVariables(frame, settings) {
+    if (!isOrganicFrame(frame))
+        return {};
+    const recipe = organicFrameRecipes[frame];
+    const variables = {};
+    for (const key of [
+        "density",
+        "cornerDensity",
+        "canopyDepth",
+        "variation",
+        "scale",
+        "stemWeight",
+        "motion",
+        "seed",
+    ])
+        variables[`--dixy-organic-${key}`] = String(settings[key]);
+    variables["--dixy-organic-style"] = String(Math.max(0, recipe.styles.indexOf(settings.style)));
+    variables["--dixy-organic-canopy"] = String(canopyShapes.indexOf(settings.canopy));
+    variables["--dixy-organic-stem"] = String(stemCharacters.indexOf(settings.stem));
+    return variables;
+}

package/dist/organic-geometry.d.ts

@@ -0,0 +1,20 @@
+export interface BorderPoint {
+    x: number;
+    y: number;
+    t: number;
+}
+export interface CornerRadius {
+    x: number;
+    y: number;
+}
+export interface BorderPath {
+    total: number;
+    corners: number[];
+    r: number;
+    at(distance: number): BorderPoint;
+}
+/** One perimeter in CSS pixels, including four independently sized elliptical corners. */
+export declare function roundedBorder(width: number, height: number, input: readonly CornerRadius[]): BorderPath;
+export declare function cssCornerRadius(value: string, width: number, height: number): CornerRadius;
+/** Conservative leaf envelope, preventing amputated tips in the overflow gutter. */
+export declare function boundedLeafLength(x: number, y: number, angle: number, length: number, width: number, height: number, gutter?: number): number;

package/dist/organic-geometry.js

@@ -0,0 +1,74 @@
+/** One perimeter in CSS pixels, including four independently sized elliptical corners. */
+export function roundedBorder(width, height, input) {
+    const w = Math.max(1, width), h = Math.max(1, height);
+    const radii = input.map(({ x, y }) => ({
+        x: Math.max(0, x),
+        y: Math.max(0, y),
+    }));
+    const fit = Math.min(1, w / Math.max(1, radii[0].x + radii[1].x), w / Math.max(1, radii[3].x + radii[2].x), h / Math.max(1, radii[0].y + radii[3].y), h / Math.max(1, radii[1].y + radii[2].y));
+    for (const radius of radii) {
+        radius.x *= fit;
+        radius.y *= fit;
+    }
+    const points = [];
+    const add = (x, y) => {
+        const prior = points.at(-1);
+        const distance = prior ? Math.hypot(x - prior.x, y - prior.y) : 0;
+        if (prior && distance < 1e-8)
+            return;
+        points.push({ x, y, d: (prior?.d ?? 0) + distance });
+    };
+    const corners = [];
+    add(radii[0].x, 0);
+    const arc = (index, cx, cy, start) => {
+        const radius = radii[index];
+        for (let step = 0; step <= 16; step++) {
+            const angle = start + ((step / 16) * Math.PI) / 2;
+            add(cx + Math.cos(angle) * radius.x, cy + Math.sin(angle) * radius.y);
+            if (step === 8)
+                corners.push(points.at(-1).d);
+        }
+    };
+    add(w - radii[1].x, 0);
+    arc(1, w - radii[1].x, radii[1].y, -Math.PI / 2);
+    add(w, h - radii[2].y);
+    arc(2, w - radii[2].x, h - radii[2].y, 0);
+    add(radii[3].x, h);
+    arc(3, radii[3].x, h - radii[3].y, Math.PI / 2);
+    add(0, radii[0].y);
+    arc(0, radii[0].x, radii[0].y, Math.PI);
+    add(radii[0].x, 0);
+    const total = points.at(-1).d;
+    return {
+        total,
+        corners,
+        r: Math.max(...radii.map((radius) => radius.x)),
+        at(distance) {
+            const d = ((distance % total) + total) % total;
+            let low = 1, high = points.length - 1;
+            while (low < high) {
+                const mid = (low + high) >> 1;
+                if (points[mid].d < d)
+                    low = mid + 1;
+                else
+                    high = mid;
+            }
+            const end = points[low], start = points[low - 1], mix = (d - start.d) / (end.d - start.d);
+            return {
+                x: start.x + (end.x - start.x) * mix,
+                y: start.y + (end.y - start.y) * mix,
+                t: Math.atan2(end.y - start.y, end.x - start.x),
+            };
+        },
+    };
+}
+export function cssCornerRadius(value, width, height) {
+    const [x, y = x] = value.trim().split(/\s+/);
+    const pixels = (part, size) => (Number.parseFloat(part) || 0) * (part.endsWith("%") ? size / 100 : 1);
+    return { x: pixels(x, width), y: pixels(y, height) };
+}
+/** Conservative leaf envelope, preventing amputated tips in the overflow gutter. */
+export function boundedLeafLength(x, y, angle, length, width, height, gutter = 28) {
+    const dx = Math.abs(Math.cos(angle)), dy = Math.abs(Math.sin(angle));
+    return Math.max(0, Math.min(length, Math.min(x + gutter, width + gutter - x) / (dx + 0.45 * dy), Math.min(y + gutter, height + gutter - y) / (dy + 0.45 * dx)));
+}

package/dist/organic-ornament.d.ts

@@ -0,0 +1,9 @@
+import type { OrnamentProps } from "./ornament-parts.js";
+import type { OrganicFrame } from "./organic-settings.js";
+import type { OrganicPainter } from "./organic-paint.js";
+/** Optional decoration; never owns a primitive's hit targets, content or semantics. */
+export declare function OrganicOrnament({ kind, skin, painter, ...props }: OrnamentProps & {
+    kind: OrganicFrame;
+    skin: string;
+    painter: OrganicPainter;
+}): import("react").JSX.Element | null;

package/dist/organic-ornament.js

@@ -0,0 +1,28 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useId, useRef } from "react";
+import { mountOrganicCanvas } from "./organic-runtime.js";
+/** Optional decoration; never owns a primitive's hit targets, content or semantics. */
+export function OrganicOrnament({ kind, skin, painter, ...props }) {
+    const canvas = useRef(null), id = useId();
+    const instance = [...id].reduce((hash, char) => (hash * 31 + char.charCodeAt(0)) % 997, 0);
+    useEffect(() => {
+        if (!canvas.current)
+            return;
+        return mountOrganicCanvas(canvas.current, kind, painter, instance, props.animate, props.motion);
+    }, [
+        kind,
+        painter,
+        instance,
+        props.animate,
+        props.motion,
+        props.effects,
+        props.ornament,
+    ]);
+    if (props.part === "theme" ||
+        props.part === "switch-thumb" ||
+        props.effects === "reduced" ||
+        props.ornament === "quiet")
+        return null;
+    return (_jsx("span", { "aria-hidden": "true", className: `dixy-skin-ornament dixy-${skin}-ornament dixy-skin-ornament-${props.part} dixy-${skin}-ornament-${props.part} dixy-organic-ornament`, "data-animated": (props.animate && props.motion !== "reduced") || undefined, "data-motion": props.motion, "data-ornament": props.ornament, children: _jsx("canvas", { ref: canvas, className: "dixy-organic-canvas", "aria-hidden": "true" }) }));
+}

package/dist/organic-paint-launch.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Painters for the 2026-12 launch frames: terminal (crt, panes), extras
+ * (swiss, azulejo, formwork, atomic), sci-fi (hud, hazard, orbit), festival
+ * (rangoli, papercut, picado, gulal, knit) and Glass UI (liquid).
+ *
+ * Same contract as organic-paint-world.ts: card space spans 0..w × 0..h with a
+ * 32px gutter; every painter clips itself away from the content box (`limits`),
+ * outlines only follow the card's own rounded rectangle via `trace()`, and
+ * motion runs only while `playing`, so reduced motion gets a still frame.
+ */
+import { type OrganicPainter } from "./organic-paint.ts";
+export declare const paintPhosphor: OrganicPainter;
+export declare const paintPanes: OrganicPainter;
+export declare const paintSwiss: OrganicPainter;
+export declare const paintAzulejo: OrganicPainter;
+export declare const paintFormwork: OrganicPainter;
+export declare const paintAtomic: OrganicPainter;
+export declare const paintHud: OrganicPainter;
+export declare const paintHazard: OrganicPainter;
+export declare const paintOrbit: OrganicPainter;
+export declare const paintRangoli: OrganicPainter;
+export declare const paintPapercut: OrganicPainter;
+export declare const paintPicado: OrganicPainter;
+export declare const paintGulal: OrganicPainter;
+export declare const paintKnit: OrganicPainter;
+export declare const paintLiquid: OrganicPainter;
+export declare const launchPainters: {
+    readonly crt: OrganicPainter;
+    readonly panes: OrganicPainter;
+    readonly swiss: OrganicPainter;
+    readonly azulejo: OrganicPainter;
+    readonly formwork: OrganicPainter;
+    readonly atomic: OrganicPainter;
+    readonly hud: OrganicPainter;
+    readonly hazard: OrganicPainter;
+    readonly orbit: OrganicPainter;
+    readonly rangoli: OrganicPainter;
+    readonly papercut: OrganicPainter;
+    readonly picado: OrganicPainter;
+    readonly gulal: OrganicPainter;
+    readonly knit: OrganicPainter;
+    readonly liquid: OrganicPainter;
+};