@penpair/marwes-ui 0.2.0 → 0.3.0

package/dist/reconciliation.js

@@ -1,104 +1,179 @@
 import { normalizeValue } from "./tokens.js";
 const set = (live, name) => live.sets.filter((entry) => entry.name === name);
 const theme = (live, group, name) => live.themes.filter((entry) => entry.group === group && entry.name === name);
-const tokenState = (token) => token ? JSON.stringify([token.type, normalizeValue(token.type, token.value), token.description || ""]) : null;
+const tokenState = (token) => token
+    ? JSON.stringify([
+        token.type,
+        normalizeValue(token.type, token.value),
+        token.description || "",
+    ])
+    : null;
 export function actionSatisfied(action, live) {
     switch (action.kind) {
-        case "createSet": return set(live, action.set).length === 1;
+        case "createSet":
+            return set(live, action.set).length === 1;
         case "addTokens":
         case "updateTokens":
         case "replaceTokens": {
             const sets = set(live, action.set);
-            return sets.length === 1 && action.tokens.every((wanted) => {
-                const actual = sets[0].tokens.filter((token) => token.name === wanted.name);
-                return actual.length === 1 && tokenState(actual[0]) === tokenState(wanted);
-            });
+            return (sets.length === 1 &&
+                action.tokens.every((wanted) => {
+                    const actual = sets[0].tokens.filter((token) => token.name === wanted.name);
+                    return actual.length === 1 && tokenState(actual[0]) === tokenState(wanted);
+                }));
         }
-        case "removeTokens": return set(live, action.set).length === 1 && action.names.every((name) => !set(live, action.set)[0].tokens.some((token) => token.name === name));
+        case "removeTokens":
+            return (set(live, action.set).length === 1 &&
+                action.names.every((name) => !set(live, action.set)[0].tokens.some((token) => token.name === name)));
         case "createTheme": {
             const found = theme(live, action.group, action.name);
-            return found.length === 1 && found[0].sets.length === action.sets.length && action.sets.every((name) => found[0].sets.includes(name));
+            return (found.length === 1 &&
+                found[0].sets.length === action.sets.length &&
+                action.sets.every((name) => found[0].sets.includes(name)));
         }
         case "syncThemeSets": {
             const found = theme(live, action.group, action.name);
-            return found.length === 1 && action.add.every((name) => found[0].sets.includes(name)) && action.remove.every((name) => !found[0].sets.includes(name));
+            return (found.length === 1 &&
+                action.add.every((name) => found[0].sets.includes(name)) &&
+                action.remove.every((name) => !found[0].sets.includes(name)));
         }
-        case "activateTheme": return theme(live, action.group, action.name).some((entry) => entry.active) && live.themes.every((entry) => !entry.active || entry.group === action.group && entry.name === action.name);
+        case "activateTheme":
+            return (theme(live, action.group, action.name).some((entry) => entry.active) &&
+                live.themes.every((entry) => !entry.active || (entry.group === action.group && entry.name === action.name)));
     }
 }
 /** Only old or explicitly desired states can be our partial write; a third value needs owner reconciliation. */
 export function reconcileAction(action, before, current) {
-    if (actionSatisfied(action, current))
+    if (actionSatisfied(action, current)) {
         return "complete";
+    }
     switch (action.kind) {
-        case "createSet": return set(current, action.set).length === 0 ? "pending" : "conflict";
+        case "createSet":
+            return set(current, action.set).length === 0 ? "pending" : "conflict";
         case "addTokens":
         case "updateTokens":
         case "replaceTokens": {
-            const oldSets = set(before, action.set), nowSets = set(current, action.set);
-            if (nowSets.length !== 1 || oldSets.length > 1)
+            const oldSets = set(before, action.set);
+            const nowSets = set(current, action.set);
+            if (nowSets.length !== 1 || oldSets.length > 1) {
                 return "conflict";
+            }
             for (const wanted of action.tokens) {
                 const oldTokens = oldSets[0]?.tokens.filter((token) => token.name === wanted.name) ?? [];
                 const nowTokens = nowSets[0].tokens.filter((token) => token.name === wanted.name);
-                if (oldTokens.length > 1 || nowTokens.length > 1)
+                if (oldTokens.length > 1 || nowTokens.length > 1) {
                     return "conflict";
-                const old = tokenState(oldTokens[0]), actual = tokenState(nowTokens[0]), desired = tokenState(wanted);
-                if (action.kind === "addTokens" && old !== null && old !== desired)
+                }
+                const old = tokenState(oldTokens[0]);
+                const actual = tokenState(nowTokens[0]);
+                const desired = tokenState(wanted);
+                if (action.kind === "addTokens" && old !== null && old !== desired) {
                     return "conflict";
-                if (action.kind !== "addTokens" && old === null)
+                }
+                if (action.kind !== "addTokens" && old === null) {
                     return "conflict";
-                if (actual !== old && actual !== desired && !(action.kind === "replaceTokens" && actual === null))
+                }
+                if (actual !== old &&
+                    actual !== desired &&
+                    !(action.kind === "replaceTokens" && actual === null)) {
                     return "conflict";
+                }
             }
             return "pending";
         }
         case "removeTokens": {
-            const oldSets = set(before, action.set), nowSets = set(current, action.set);
-            if (oldSets.length !== 1 || nowSets.length !== 1)
+            const oldSets = set(before, action.set);
+            const nowSets = set(current, action.set);
+            if (oldSets.length !== 1 || nowSets.length !== 1) {
                 return "conflict";
+            }
             return action.names.every((name) => {
                 const old = oldSets[0].tokens.filter((token) => token.name === name);
                 const actual = nowSets[0].tokens.filter((token) => token.name === name);
-                return actual.length <= 1 && (actual.length === 0 || old.length === 1 && tokenState(old[0]) === tokenState(actual[0]));
-            }) ? "pending" : "conflict";
+                return (actual.length <= 1 &&
+                    (actual.length === 0 ||
+                        (old.length === 1 && tokenState(old[0]) === tokenState(actual[0]))));
+            })
+                ? "pending"
+                : "conflict";
         }
         case "createTheme": {
-            const old = theme(before, action.group, action.name), actual = theme(current, action.group, action.name);
-            return old.length === 0 && actual.length <= 1 && (actual.length === 0 || actual[0].sets.every((name) => action.sets.includes(name))) ? "pending" : "conflict";
+            const old = theme(before, action.group, action.name);
+            const actual = theme(current, action.group, action.name);
+            return old.length === 0 &&
+                actual.length <= 1 &&
+                (actual.length === 0 || actual[0].sets.every((name) => action.sets.includes(name)))
+                ? "pending"
+                : "conflict";
         }
         case "syncThemeSets": {
-            const old = theme(before, action.group, action.name), actual = theme(current, action.group, action.name);
-            if (old.length !== 1 || actual.length !== 1)
+            const old = theme(before, action.group, action.name);
+            const actual = theme(current, action.group, action.name);
+            if (old.length !== 1 || actual.length !== 1) {
                 return "conflict";
-            const touched = new Set([...action.add, ...action.remove]);
-            const unchanged = (sets) => sets.filter((name) => !touched.has(name)).sort().join("\n");
+            }
+            const touched = new Set([
+                ...action.add,
+                ...action.remove,
+            ]);
+            const unchanged = (sets) => sets
+                .filter((name) => !touched.has(name))
+                .sort()
+                .join("\n");
             return unchanged(old[0].sets) === unchanged(actual[0].sets) ? "pending" : "conflict";
         }
         case "activateTheme": {
-            const active = (live) => live.themes.filter((entry) => entry.active).map((entry) => JSON.stringify([entry.group, entry.name])).sort().join("\n");
+            const active = (live) => live.themes
+                .filter((entry) => entry.active)
+                .map((entry) => JSON.stringify([
+                entry.group,
+                entry.name,
+            ]))
+                .sort()
+                .join("\n");
             return active(current) === active(before) || active(current) === "" ? "pending" : "conflict";
         }
     }
 }
 /** Recompute residual work from actual state so completed token replacements are never removed/recreated again. */
 export function remainingAction(action, current) {
-    if (actionSatisfied(action, current))
+    if (actionSatisfied(action, current)) {
         return undefined;
+    }
     if ("tokens" in action) {
         const actual = set(current, action.set)[0];
-        const tokens = action.tokens.filter((wanted) => tokenState(actual?.tokens.find((token) => token.name === wanted.name)) !== tokenState(wanted));
-        return tokens.length ? { ...action, tokens } : undefined;
+        const tokens = action.tokens.filter((wanted) => tokenState(actual?.tokens.find((token) => token.name === wanted.name)) !==
+            tokenState(wanted));
+        return tokens.length
+            ? {
+                ...action,
+                tokens,
+            }
+            : undefined;
+    }
+    if (action.kind === "removeTokens") {
+        return {
+            ...action,
+            names: action.names.filter((name) => set(current, action.set)[0]?.tokens.some((token) => token.name === name)),
+        };
     }
-    if (action.kind === "removeTokens")
-        return { ...action, names: action.names.filter((name) => set(current, action.set)[0]?.tokens.some((token) => token.name === name)) };
     if (action.kind === "createTheme" && theme(current, action.group, action.name).length === 1) {
         const actual = theme(current, action.group, action.name)[0];
-        return { kind: "syncThemeSets", group: action.group, name: action.name, add: action.sets.filter((name) => !actual.sets.includes(name)), remove: [] };
+        return {
+            kind: "syncThemeSets",
+            group: action.group,
+            name: action.name,
+            add: action.sets.filter((name) => !actual.sets.includes(name)),
+            remove: [],
+        };
     }
     if (action.kind === "syncThemeSets") {
         const actual = theme(current, action.group, action.name)[0];
-        return { ...action, add: action.add.filter((name) => !actual.sets.includes(name)), remove: action.remove.filter((name) => actual.sets.includes(name)) };
+        return {
+            ...action,
+            add: action.add.filter((name) => !actual.sets.includes(name)),
+            remove: action.remove.filter((name) => actual.sets.includes(name)),
+        };
     }
     return action;
 }

package/dist/resolved-values.d.ts

@@ -1,12 +1,7 @@
 import { type TokenSnapshot } from "./tokens.js";
-export interface ResolvedExpectation {
-    name: string;
-    type: string;
-    value?: unknown;
-    unknown?: string;
-}
-/** A small arithmetic grammar, never JavaScript evaluation. Unsupported units/functions are explicit unknowns. */
-export declare function numericExpression(source: string): number;
+import { type ResolvedDeclaredToken } from "@penpair/core";
+export { numericExpression } from "@penpair/core";
+export type ResolvedExpectation = ResolvedDeclaredToken;
 export declare function expectedResolved(snapshot: TokenSnapshot, theme: {
     sets: string[];
 }): ResolvedExpectation[];

package/dist/resolved-values.js

@@ -1,128 +1,124 @@
 import { canonical, normalizeValue, toHexColor } from "./tokens.js";
-/** A small arithmetic grammar, never JavaScript evaluation. Unsupported units/functions are explicit unknowns. */
-export function numericExpression(source) {
-    if (source.length > 2000)
-        throw new Error("Expression budget exceeded");
-    const tokens = source.match(/(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|[()+*/-]/gi) ?? [];
-    if (tokens.join("") !== source.replace(/\s+/g, "") || tokens.length > 500)
-        throw new Error("Unsupported numeric expression");
-    let index = 0, depth = 0;
-    const atom = () => {
-        if (++depth > 64)
-            throw new Error("Expression depth exceeded");
-        const token = tokens[index++];
-        let value;
-        if (token === "(") {
-            value = sum();
-            if (tokens[index++] !== ")")
-                throw new Error("Unclosed expression");
-        }
-        else if (token === "-")
-            value = -atom();
-        else if (token === "+")
-            value = atom();
-        else {
-            if (!token || !/^[\d.]/.test(token))
-                throw new Error("Missing number");
-            value = Number(token);
-        }
-        depth--;
-        if (!Number.isFinite(value))
-            throw new Error("Nonfinite expression");
-        return value;
-    };
-    const product = () => { let value = atom(); while (["*", "/"].includes(tokens[index] ?? "")) {
-        const op = tokens[index++], right = atom();
-        value = op === "*" ? value * right : value / right;
-    } return value; };
-    const sum = () => { let value = product(); while (["+", "-"].includes(tokens[index] ?? "")) {
-        const op = tokens[index++], right = product();
-        value = op === "+" ? value + right : value - right;
-    } return value; };
-    const value = sum();
-    if (index !== tokens.length || !Number.isFinite(value))
-        throw new Error("Invalid numeric expression");
-    return value;
-}
-const numericTypes = new Set(["borderRadius", "dimension", "fontSizes", "letterSpacing", "number", "opacity", "rotation", "sizing", "spacing", "borderWidth"]);
+import { numericExpression, resolveDeclaredTokens, } from "@penpair/core";
+export { numericExpression } from "@penpair/core";
+const numericTypes = new Set([
+    "borderRadius",
+    "dimension",
+    "fontSizes",
+    "letterSpacing",
+    "number",
+    "opacity",
+    "rotation",
+    "sizing",
+    "spacing",
+    "borderWidth",
+]);
 export function expectedResolved(snapshot, theme) {
-    const effective = new Map(snapshot.sets.filter(set => theme.sets.includes(set.name)).flatMap(set => set.tokens.map(token => [token.name, token])));
-    const resolve = (name, visiting = new Set()) => {
-        if (visiting.has(name) || visiting.size >= 64)
-            throw new Error("Cyclic or over-deep reference");
-        const token = effective.get(name);
-        if (!token)
-            throw new Error("Missing referenced token: " + name);
-        const next = new Set(visiting);
-        next.add(name);
-        const value = (input) => {
-            if (typeof input === "string") {
-                const alias = /^\{([^{}]+)\}$/.exec(input);
-                if (alias)
-                    return resolve(alias[1], next);
-                return input.replace(/\{([^{}]+)\}/g, (_match, reference) => {
-                    const resolved = resolve(reference, next);
-                    if (typeof resolved !== "number" && typeof resolved !== "string")
-                        throw new Error("Composite interpolation unsupported");
-                    return String(resolved);
-                });
-            }
-            if (input && typeof input === "object" && !Array.isArray(input))
-                return Object.fromEntries(Object.entries(input).map(([key, entry]) => [key, value(entry)]));
-            return input;
-        };
-        const resolved = value(token.value);
-        return numericTypes.has(token.type) ? typeof resolved === "number" ? resolved : numericExpression(String(resolved)) : resolved;
-    };
-    return [...effective.values()].map(token => { try {
-        return { name: token.name, type: token.type, value: resolve(token.name) };
-    }
-    catch (error) {
-        return { name: token.name, type: token.type, unknown: String(error.message) };
-    } });
+    return resolveDeclaredTokens(snapshot, theme.sets);
 }
 export function compareResolved(wanted, actual) {
-    if (wanted.unknown)
-        return { unknown: wanted.unknown };
-    if (actual === undefined || actual === null)
-        return { unknown: "API resolvedValue is unavailable" };
+    if (wanted.unknown) {
+        return {
+            unknown: wanted.unknown,
+        };
+    }
+    if (actual === undefined || actual === null) {
+        return {
+            unknown: "API resolvedValue is unavailable",
+        };
+    }
     try {
         if (numericTypes.has(wanted.type)) {
             const value = typeof actual === "number" ? actual : numericExpression(String(actual));
-            return { equal: typeof wanted.value === "number" && Math.abs(value - wanted.value) <= 1e-9 * Math.max(1, Math.abs(wanted.value)) };
+            return {
+                equal: typeof wanted.value === "number" &&
+                    Math.abs(value - wanted.value) <= 1e-9 * Math.max(1, Math.abs(wanted.value)),
+            };
         }
         if (wanted.type === "color") {
-            const color = (value) => { if (typeof value !== "string")
-                throw new Error("Unsupported resolved color"); const expanded = /^#[0-9a-f]{3,4}$/i.test(value) ? "#" + value.slice(1).split("").map(c => c + c).join("") : value; const hex = toHexColor(expanded); return hex.length === 9 && hex.endsWith("FF") ? hex.slice(0, -2) : hex; };
-            return { equal: color(wanted.value) === color(actual) };
+            const color = (value) => {
+                if (typeof value !== "string") {
+                    throw new Error("Unsupported resolved color");
+                }
+                const expanded = /^#[0-9a-f]{3,4}$/i.test(value)
+                    ? "#" +
+                        value
+                            .slice(1)
+                            .split("")
+                            .map((c) => c + c)
+                            .join("")
+                    : value;
+                const hex = toHexColor(expanded);
+                return hex.length === 9 && hex.endsWith("FF") ? hex.slice(0, -2) : hex;
+            };
+            return {
+                equal: color(wanted.value) === color(actual),
+            };
+        }
+        if (wanted.type === "fontFamilies" &&
+            Array.isArray(actual) &&
+            !actual.every((value) => typeof value === "string")) {
+            return {
+                unknown: "Unsupported nested font resolution",
+            };
+        }
+        if (wanted.type === "shadow") {
+            return {
+                unknown: "Composite shadow resolution has no supported comparison model",
+            };
         }
-        if (wanted.type === "fontFamilies" && Array.isArray(actual) && !actual.every(value => typeof value === "string"))
-            return { unknown: "Unsupported nested font resolution" };
-        if (wanted.type === "shadow")
-            return { unknown: "Composite shadow resolution has no supported comparison model" };
         if (wanted.type === "typography") {
             const normalize = (input) => {
-                const object = Array.isArray(input) ? input.length === 1 ? input[0] : undefined : input;
-                if (!object || typeof object !== "object" || Array.isArray(object))
+                const object = Array.isArray(input) ? (input.length === 1 ? input[0] : undefined) : input;
+                if (!object || typeof object !== "object" || Array.isArray(object)) {
                     throw new Error("Unsupported typography resolution");
-                const aliases = { fontFamilies: "fontFamily", fontSizes: "fontSize", fontWeights: "fontWeight" };
+                }
+                const aliases = {
+                    fontFamilies: "fontFamily",
+                    fontSizes: "fontSize",
+                    fontWeights: "fontWeight",
+                };
                 return Object.fromEntries(Object.entries(object).map(([key, value]) => {
                     key = aliases[key] ?? key;
                     if (key === "fontFamily") {
-                        const family = Array.isArray(value) ? value : [value];
-                        if (!family.every(v => typeof v === "string"))
+                        const family = Array.isArray(value)
+                            ? value
+                            : [
+                                value,
+                            ];
+                        if (!family.every((v) => typeof v === "string")) {
                             throw new Error("Unsupported nested font resolution");
-                        return [key, family];
+                        }
+                        return [
+                            key,
+                            family,
+                        ];
                     }
-                    return [key, ["fontSize", "letterSpacing", "lineHeight"].includes(key) ? String(numericExpression(String(value))) : String(value)];
+                    return [
+                        key,
+                        [
+                            "fontSize",
+                            "letterSpacing",
+                            "lineHeight",
+                        ].includes(key)
+                            ? String(numericExpression(String(value)))
+                            : String(value),
+                    ];
                 }));
             };
-            const expected = normalize(wanted.value), observed = normalize(actual);
-            return { equal: Object.keys(expected).every(key => canonical(expected[key]) === canonical(observed[key])) };
+            const expected = normalize(wanted.value);
+            const observed = normalize(actual);
+            return {
+                equal: Object.keys(expected).every((key) => canonical(expected[key]) === canonical(observed[key])),
+            };
         }
-        return { equal: normalizeValue(wanted.type, wanted.value) === normalizeValue(wanted.type, actual) };
+        return {
+            equal: normalizeValue(wanted.type, wanted.value) === normalizeValue(wanted.type, actual),
+        };
     }
     catch (error) {
-        return { unknown: String(error.message) };
+        return {
+            unknown: String(error.message),
+        };
     }
 }