@penpair/marwes-ui 0.1.3 → 0.3.0

package/dist/reconciliation.d.ts

@@ -0,0 +1,6 @@
+import type { Action, LiveTokens } from "./penpot.js";
+export declare function actionSatisfied(action: Action, live: LiveTokens): boolean;
+/** Only old or explicitly desired states can be our partial write; a third value needs owner reconciliation. */
+export declare function reconcileAction(action: Action, before: LiveTokens, current: LiveTokens): "complete" | "pending" | "conflict";
+/** Recompute residual work from actual state so completed token replacements are never removed/recreated again. */
+export declare function remainingAction(action: Action, current: LiveTokens): Action | undefined;

package/dist/reconciliation.js

@@ -0,0 +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;
+export function actionSatisfied(action, live) {
+    switch (action.kind) {
+        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);
+                }));
+        }
+        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)));
+        }
+        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)));
+        }
+        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)) {
+        return "complete";
+    }
+    switch (action.kind) {
+        case "createSet":
+            return set(current, action.set).length === 0 ? "pending" : "conflict";
+        case "addTokens":
+        case "updateTokens":
+        case "replaceTokens": {
+            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) {
+                    return "conflict";
+                }
+                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) {
+                    return "conflict";
+                }
+                if (actual !== old &&
+                    actual !== desired &&
+                    !(action.kind === "replaceTokens" && actual === null)) {
+                    return "conflict";
+                }
+            }
+            return "pending";
+        }
+        case "removeTokens": {
+            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";
+        }
+        case "createTheme": {
+            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);
+            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");
+            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");
+            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)) {
+        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;
+    }
+    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: [],
+        };
+    }
+    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;
+}

package/dist/resolved-values.d.ts

@@ -0,0 +1,11 @@
+import { type TokenSnapshot } from "./tokens.js";
+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[];
+export declare function compareResolved(wanted: ResolvedExpectation, actual: unknown): {
+    equal?: boolean;
+    unknown?: string;
+};

package/dist/resolved-values.js

@@ -0,0 +1,124 @@
+import { canonical, normalizeValue, toHexColor } from "./tokens.js";
+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) {
+    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",
+        };
+    }
+    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)),
+            };
+        }
+        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),
+            };
+        }
+        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)) {
+                    throw new Error("Unsupported typography resolution");
+                }
+                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")) {
+                            throw new Error("Unsupported nested font resolution");
+                        }
+                        return [
+                            key,
+                            family,
+                        ];
+                    }
+                    return [
+                        key,
+                        [
+                            "fontSize",
+                            "letterSpacing",
+                            "lineHeight",
+                        ].includes(key)
+                            ? String(numericExpression(String(value)))
+                            : String(value),
+                    ];
+                }));
+            };
+            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),
+        };
+    }
+    catch (error) {
+        return {
+            unknown: String(error.message),
+        };
+    }
+}

package/dist/snapshot-file.d.ts

@@ -41,3 +41,48 @@ export interface SnapshotDiff {
 export declare function diffSnapshots(before: TokenSnapshot | undefined, after: TokenSnapshot): SnapshotDiff;
 /** A short, readable account of a diff for the terminal; long lists are cut with a count. */
 export declare function formatDiff(diff: SnapshotDiff, limit?: number): string[];
+/** Explicitly classify every legacy set; names cannot establish ownership. Original fields survive migration. */
+export declare function migrateTokenSnapshot(raw: unknown, ownership: Record<string, "adapter" | "project">): TokenSnapshot;
+export declare const tokenSnapshotSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "urn:penpair:schema:v2:adapter-token-snapshot";
+    readonly type: "object";
+    readonly required: readonly ["schemaVersion", "ownership", "marwesVersion", "generatedBy", "project", "hash", "sets", "themes", "unmapped"];
+    readonly properties: {
+        readonly schemaVersion: {
+            readonly const: 2;
+        };
+        readonly ownership: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly enum: readonly ["adapter", "project"];
+            };
+        };
+        readonly marwesVersion: {
+            readonly type: "string";
+        };
+        readonly generatedBy: {
+            readonly type: "string";
+        };
+        readonly project: {
+            readonly type: "string";
+        };
+        readonly hash: {
+            readonly type: "string";
+            readonly pattern: "^[a-f0-9]{64}$";
+        };
+        readonly sets: {
+            readonly type: "array";
+        };
+        readonly themes: {
+            readonly type: "array";
+        };
+        readonly unmapped: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly additionalProperties: true;
+};