@plitzi/sdk-mcp 0.38.6 → 0.38.8

package/dist/modules/mcp/tools/operations/style/validate.js

@@ -0,0 +1,63 @@
+import { expandShorthand } from "../../../catalogs/index.js";
+import { fail } from "../../../helpers/opResult.js";
+import { STYLE_MOTION_CONDITIONS, canonicalCondition } from "@plitzi/sdk-shared/style/styleConditions";
+import { CONTENT_PSEUDOS, GENERATED_PSEUDOS, PSEUDO_PROPERTIES, STYLE_PSEUDOS, isContentValue, isStylePseudo, pseudoHonours } from "@plitzi/sdk-shared/style/stylePseudos";
+//#region src/modules/mcp/tools/operations/style/validate.ts
+var MODES = [
+	"desktop",
+	"tablet",
+	"mobile"
+];
+var CONDITION_HINT = `Use ${STYLE_MOTION_CONDITIONS.join(" or ")}, or a container's width — "container (max-width: 30rem)", "container card (min-width: 480px)" (min-width, max-width or both joined by "and", in px, rem, em or ch).`;
+/** Every rule set of a part — per breakpoint and in each of its states — as it is stored: longhands. */
+var rulesOf = (part) => [...MODES.flatMap((mode) => part[mode] ? [expandShorthand(part[mode])] : []), ...Object.values(part.states ?? {}).flatMap((states) => MODES.flatMap((mode) => states[mode] ? [expandShorthand(states[mode])] : []))];
+var pseudoProblem = (path, name, part) => {
+	if (!isStylePseudo(name)) {
+		const bare = name.replace(/^:+/, "");
+		return fail(path, `"${name}" is not a pseudo-element a class dresses`, isStylePseudo(bare) ? `Write it without the colons: "${bare}".` : `Use one of ${STYLE_PSEUDOS.join(", ")}.`, [...STYLE_PSEUDOS]);
+	}
+	const rules = rulesOf(part);
+	for (const rule of rules) for (const [property, value] of Object.entries(rule)) {
+		if (property === "content") {
+			if (!CONTENT_PSEUDOS.includes(name)) return fail(path, `content on ::${name} draws nothing`, `Only ${CONTENT_PSEUDOS.map((pseudo) => `::${pseudo}`).join(", ")} take one.`);
+			if (!isContentValue(String(value))) return fail(path, `content: ${String(value)} on ::${name} is not text CSS can read, so nothing is drawn`, `Write the text in quotes inside the string — "\\"${String(value)}\\"" — and an empty box as "\\"\\""; counter(), attr() and url() are written as they are.`);
+			continue;
+		}
+		if (!pseudoHonours(name, property)) return fail(path, `${property} on ::${name} is dropped by every browser`, `::${name} honours ${(PSEUDO_PROPERTIES[name] ?? []).join(", ")}; style the element itself for the rest.`);
+	}
+	if (GENERATED_PSEUDOS.includes(name) && !rules.some((rule) => Object.hasOwn(rule, "content"))) return fail(path, `::${name} has no content, so nothing is drawn`, "Give it one: content \"\\\"\\\"\" for an empty box.");
+	return null;
+};
+var pseudosProblem = (path, pseudos) => {
+	for (const [name, part] of Object.entries(pseudos ?? {})) {
+		const problem = pseudoProblem(`${path}pseudos.${name}`, name, part);
+		if (problem) return problem;
+	}
+	return null;
+};
+var slotProblem = (path, slot) => {
+	const own = pseudosProblem(path, slot.pseudos);
+	if (own) return own;
+	for (const [name, variant] of Object.entries(slot.variants ?? {})) {
+		const problem = pseudosProblem(`${path}variants.${name}.`, variant.pseudos);
+		if (problem) return problem;
+	}
+	for (const [key, condition] of Object.entries(slot.conditions ?? {})) {
+		if (!canonicalCondition(key)) return fail(`${path}conditions.${key}`, `"${key}" is not a condition a class's rules can hold under`, CONDITION_HINT);
+		const problem = pseudosProblem(`${path}conditions.${key}.`, condition.pseudos);
+		if (problem) return problem;
+	}
+	return null;
+};
+/** The first problem with a style write — its base selector, then each slot — or `null` when it can be written. */
+var styleInputProblem = (base, slots) => {
+	const own = slotProblem("", base);
+	if (own) return own;
+	for (const [name, slot] of Object.entries(slots ?? {})) {
+		const problem = slotProblem(`slots.${name}.`, slot);
+		if (problem) return problem;
+	}
+	return null;
+};
+//#endregion
+export { styleInputProblem };

package/dist/modules/mcp/tools/operations/style/write.d.ts

@@ -5,7 +5,7 @@ import { DisplayMode, Style, TagType } from '@plitzi/sdk-shared';
 export declare const MODES: DisplayMode[];
 export { defUri, defsUri, globalUri, globalsUri, idUri, idsUri, styleVarUri, styleVarsUri } from '../../../helpers';
 export declare const guardKind: (style: Style, ref: string, want: TagType) => OpResult | null;
-export declare const writeStyleItem: (style: Style, ref: string, base: DefinitionSlotInput, slots: Record<string, DefinitionSlotInput> | undefined, itemType: TagType, componentType: string | undefined) => void;
+export declare const writeStyleItem: (style: Style, ref: string, base: DefinitionSlotInput, slots: Record<string, DefinitionSlotInput> | undefined, itemType: TagType, componentType: string | undefined) => OpResult | null;
 export declare const mergePatch: (existing: AIDefinition, basePatch: DefinitionSlotPatch, slotsPatch: Record<string, DefinitionSlotPatch> | undefined) => {
     base: DefinitionSlotInput;
     slots: Record<string, DefinitionSlotInput> | undefined;

package/dist/modules/mcp/tools/operations/style/write.js

@@ -1,6 +1,9 @@
 import { defUri, defsUri, globalUri, globalsUri, idUri, idsUri, styleVarUri, styleVarsUri } from "../../../helpers/uris.js";
 import { expandShorthand, expandShorthandPatch } from "../../../catalogs/index.js";
 import { fail } from "../../../helpers/opResult.js";
+import { styleInputProblem } from "./validate.js";
+import { canonicalCondition } from "@plitzi/sdk-shared/style/styleConditions";
+import { isStylePseudo } from "@plitzi/sdk-shared/style/stylePseudos";
 import processSelector from "@plitzi/sdk-style/helpers/processSelector";
 //#region src/modules/mcp/tools/operations/style/write.ts
 var MODES = [
@@ -28,6 +31,30 @@ var guardKind = (style, ref, want) => {
 	if (!clash) return null;
 	return fail(KIND_FIELD[want], `"${ref}" is already ${KIND_LABEL[clash.type]}; it cannot be edited as ${KIND_LABEL[want]}`, `Edit it with ${KIND_TOOL[clash.type]}, or choose a different ${KIND_FIELD[want]}.`);
 };
+/** A part with rules and states — a pseudo-element, a variant, a condition — at one breakpoint, or nothing there. */
+var partAt = (part, mode) => {
+	const block = {};
+	const css = part[mode];
+	if (css && Object.keys(css).length > 0) block.default = expandShorthand(css);
+	for (const [state, dm] of Object.entries(part.states ?? {})) if (dm[mode]) (block.states ??= {})[state] = expandShorthand(dm[mode]);
+	return block.default || block.states ? block : void 0;
+};
+var pseudosAt = (pseudos, mode) => {
+	const entries = Object.entries(pseudos ?? {}).flatMap(([pseudo, part]) => {
+		const block = partAt(part, mode);
+		return block && isStylePseudo(pseudo) ? [[pseudo, block]] : [];
+	});
+	return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+};
+/** A variant or a condition at one breakpoint: its own part, and its pseudo-elements'. */
+var variantAt = (part, mode) => {
+	const block = partAt(part, mode);
+	const pseudos = pseudosAt(part.pseudos, mode);
+	return block || pseudos ? {
+		...block,
+		...pseudos ? { pseudos } : {}
+	} : void 0;
+};
 var slotToBlocks = (slot) => {
 	const perMode = {};
 	for (const mode of MODES) {
@@ -35,7 +62,20 @@ var slotToBlocks = (slot) => {
 		const baseCss = slot[mode];
 		if (baseCss && Object.keys(baseCss).length > 0) block.default = expandShorthand(baseCss);
 		for (const [state, dm] of Object.entries(slot.states ?? {})) if (dm[mode]) (block.states ??= {})[state] = expandShorthand(dm[mode]);
-		for (const [name, dm] of Object.entries(slot.variants ?? {})) if (dm[mode]) (block.variants ??= {})[name] = { default: expandShorthand(dm[mode]) };
+		for (const [name, variant] of Object.entries(slot.variants ?? {})) {
+			const variantBlock = variantAt(variant, mode);
+			if (variantBlock) (block.variants ??= {})[name] = {
+				default: {},
+				...variantBlock
+			};
+		}
+		const pseudos = pseudosAt(slot.pseudos, mode);
+		if (pseudos) block.pseudos = pseudos;
+		for (const [key, condition] of Object.entries(slot.conditions ?? {})) {
+			const conditionBlock = variantAt(condition, mode);
+			const canonical = canonicalCondition(key) ?? key;
+			if (conditionBlock) (block.conditions ??= {})[canonical] = conditionBlock;
+		}
 		for (const [ancestor, condition] of Object.entries(slot.ancestors ?? {})) {
 			const conditionBlock = slotToBlocks(condition)[mode];
 			if (conditionBlock) (block.ancestors ??= {})[ancestor] = {
@@ -49,6 +89,8 @@ var slotToBlocks = (slot) => {
 	return perMode;
 };
 var writeStyleItem = (style, ref, base, slots, itemType, componentType) => {
+	const problem = styleInputProblem(base, slots);
+	if (problem) return problem;
 	for (const mode of MODES) {
 		const attributes = {};
 		const baseBlocks = slotToBlocks(base);
@@ -70,6 +112,7 @@ var writeStyleItem = (style, ref, base, slots, itemType, componentType) => {
 			style.platform[mode][ref] = styleItem;
 		}
 	}
+	return null;
 };
 var mergeCss = (base, patch) => {
 	const merged = { ...base };
@@ -111,14 +154,57 @@ var mergeAncestors = (base, patch) => {
 	}
 	return Object.keys(result).length > 0 ? result : void 0;
 };
+var mergePart = (base, patch) => {
+	const merged = mergeDisplayMode(base, patch);
+	const states = mergeNamedModes(base?.states, patch?.states);
+	if (states) merged.states = states;
+	return merged;
+};
+var mergePseudos = (base, patch) => {
+	const names = /* @__PURE__ */ new Set([...Object.keys(base ?? {}), ...Object.keys(patch ?? {})]);
+	const result = {};
+	for (const name of names) {
+		const partPatch = patch?.[name];
+		if (partPatch === null) continue;
+		const merged = mergePart(base?.[name], partPatch);
+		if (Object.keys(merged).length > 0) result[name] = merged;
+	}
+	return Object.keys(result).length > 0 ? result : void 0;
+};
+var mergeVariantPart = (base, patch) => {
+	const merged = mergePart(base, patch);
+	const pseudos = mergePseudos(base?.pseudos, patch?.pseudos);
+	if (pseudos) merged.pseudos = pseudos;
+	return merged;
+};
+/**
+* Variants or conditions, each merged whole — its rules, states and pseudo-elements — and one patched to `null`
+* removed. A condition is matched by the one spelling the document keeps, so a patch may write it as it likes.
+*/
+var mergeVariantParts = (base, patch, keyOf = (key) => key) => {
+	const patches = new Map(Object.entries(patch ?? {}).map(([key, value]) => [keyOf(key), value]));
+	const names = /* @__PURE__ */ new Set([...Object.keys(base ?? {}), ...patches.keys()]);
+	const result = {};
+	for (const name of names) {
+		const partPatch = patches.get(name);
+		if (partPatch === null) continue;
+		const merged = mergeVariantPart(base?.[name], partPatch);
+		if (Object.keys(merged).length > 0) result[name] = merged;
+	}
+	return Object.keys(result).length > 0 ? result : void 0;
+};
 var mergeSlot = (base, patch) => {
 	const merged = mergeDisplayMode(base, patch);
 	const states = mergeNamedModes(base?.states, patch.states);
 	if (states) merged.states = states;
-	const variants = mergeNamedModes(base?.variants, patch.variants);
+	const variants = mergeVariantParts(base?.variants, patch.variants);
 	if (variants) merged.variants = variants;
 	const ancestors = mergeAncestors(base?.ancestors, patch.ancestors);
 	if (ancestors) merged.ancestors = ancestors;
+	const pseudos = mergePseudos(base?.pseudos, patch.pseudos);
+	if (pseudos) merged.pseudos = pseudos;
+	const conditions = mergeVariantParts(base?.conditions, patch.conditions, (key) => canonicalCondition(key) ?? key);
+	if (conditions) merged.conditions = conditions;
 	return merged;
 };
 var mergePatch = (existing, basePatch, slotsPatch) => {