@trojanbox-vcp-test/site-edit-engine 0.1.0

package/dist/internal/ast/primitives/style/style-primitives.js

@@ -0,0 +1,555 @@
+import { objectProperty, stringLiteral } from "@babel/types";
+import { primitiveFailure } from "../../diagnostics/index.js";
+import { createJsxAttribute, objectPropertyKey, parseMutationSource, printMutationWithOperation, resolveOptionalJsxAttribute, resolveRequiredJsxAttribute, resolveRequiredJsxElement, valueToExpression, } from "../shared.js";
+import { analyzeClassExpression, } from "./class-expression.js";
+export function setJsxAttribute(params) {
+    const { source, locator, value } = params;
+    const parsed = parseMutationSource(source, "jsx-attribute");
+    if (!parsed.ok) {
+        return parsed.result;
+    }
+    const elementMatch = resolveRequiredJsxElement(parsed.ast, locator.element, source);
+    if (!elementMatch.ok) {
+        return elementMatch.result;
+    }
+    const attributes = elementMatch.match.path.node.openingElement.attributes;
+    // Check if target attribute is followed by any spread attribute
+    const targetIndex = attributes.findIndex((attribute) => attribute.type === "JSXAttribute" &&
+        attribute.name.type === "JSXIdentifier" &&
+        attribute.name.name === locator.name);
+    if (targetIndex >= 0) {
+        const hasSpreadAfter = attributes.some((attribute, index) => index > targetIndex && attribute.type === "JSXSpreadAttribute");
+        if (hasSpreadAfter) {
+            return primitiveFailure(source, "unsupported-syntax", "cannot edit explicit attribute when spread props follow it", "jsx-attribute");
+        }
+    }
+    const existing = attributes.find((attribute) => attribute.type === "JSXAttribute" &&
+        attribute.name.type === "JSXIdentifier" &&
+        attribute.name.name === locator.name);
+    if (existing && existing.type === "JSXAttribute") {
+        existing.value = createJsxAttribute(locator.name, value).value;
+    }
+    else {
+        attributes.push(createJsxAttribute(locator.name, value));
+    }
+    return printMutationWithOperation(parsed.ast, source, {
+        kind: "set-jsx-attribute",
+        target: "jsx-attribute",
+        inverse: "remove-jsx-attribute",
+    });
+}
+export function removeJsxAttribute(params) {
+    const { source, locator } = params;
+    const parsed = parseMutationSource(source, "jsx-attribute");
+    if (!parsed.ok) {
+        return parsed.result;
+    }
+    const elementMatch = resolveRequiredJsxElement(parsed.ast, locator.element, source);
+    if (!elementMatch.ok) {
+        return elementMatch.result;
+    }
+    elementMatch.match.path.node.openingElement.attributes =
+        elementMatch.match.path.node.openingElement.attributes.filter((attribute) => attribute.type !== "JSXAttribute" ||
+            attribute.name.type !== "JSXIdentifier" ||
+            attribute.name.name !== locator.name);
+    return printMutationWithOperation(parsed.ast, source, {
+        kind: "remove-jsx-attribute",
+        target: "jsx-attribute",
+        inverse: "set-jsx-attribute",
+    });
+}
+export function updateClassName(params) {
+    const dynamicResult = updateDynamicClassName(params);
+    if (dynamicResult.handled) {
+        return dynamicResult.result;
+    }
+    return setJsxAttribute({
+        source: params.source,
+        locator: params.locator,
+        value: params.value,
+    });
+}
+export function addTailwindClass(params) {
+    /* node:coverage ignore start */
+    return mutateTailwindClassTokens(params.source, params.locator, (tokens) => {
+        tokens.add(params.token);
+    }, "first");
+    /* node:coverage ignore stop */
+}
+export function removeTailwindClass(params) {
+    /* node:coverage ignore start */
+    return mutateTailwindClassTokens(params.source, params.locator, (tokens) => {
+        tokens.delete(params.token);
+    }, "all");
+    /* node:coverage ignore stop */
+}
+export function updateStyleProperty(params) {
+    const { source, locator, property, value } = params;
+    const parsed = parseMutationSource(source, "jsx-attribute");
+    if (!parsed.ok) {
+        return parsed.result;
+    }
+    const attributeMatch = resolveStyleAttributeForUpdate(parsed.ast, locator, source);
+    if (!attributeMatch.ok) {
+        return attributeMatch.result;
+    }
+    const attributePath = attributeMatch.path;
+    const attributeValue = attributePath.get("value");
+    if (!attributeValue.isJSXExpressionContainer()) {
+        return primitiveFailure(source, "unsupported-syntax", "style attribute must use JSX expression container", "jsx-attribute");
+    }
+    const expression = attributeValue.get("expression");
+    if (!expression.isObjectExpression()) {
+        return primitiveFailure(source, "unsupported-syntax", "style attribute must contain object literal", "jsx-attribute");
+    }
+    if (expression.node.properties.some((item) => item.type !== "ObjectProperty")) {
+        return primitiveFailure(source, "unsupported-syntax", "style object cannot contain spread properties", "jsx-attribute");
+    }
+    setStyleObjectProperty(expression, property, value);
+    return printMutationWithOperation(parsed.ast, source, {
+        kind: "update-style-property",
+        target: "jsx-attribute",
+        inverse: "remove-style-property",
+    });
+}
+export function updateStyleProperties(params) {
+    const { source, locator, properties } = params;
+    const parsed = parseMutationSource(source, "jsx-attribute");
+    if (!parsed.ok) {
+        return parsed.result;
+    }
+    const attributeMatch = resolveStyleAttributeForUpdate(parsed.ast, locator, source);
+    if (!attributeMatch.ok) {
+        return attributeMatch.result;
+    }
+    const attributePath = attributeMatch.path;
+    const attributeValue = attributePath.get("value");
+    if (!attributeValue.isJSXExpressionContainer()) {
+        return primitiveFailure(source, "unsupported-syntax", "style attribute must use JSX expression container", "jsx-attribute");
+    }
+    const expression = attributeValue.get("expression");
+    if (!expression.isObjectExpression()) {
+        return primitiveFailure(source, "unsupported-syntax", "style attribute must contain object literal", "jsx-attribute");
+    }
+    if (expression.node.properties.some((item) => item.type !== "ObjectProperty")) {
+        return primitiveFailure(source, "unsupported-syntax", "style object cannot contain spread properties", "jsx-attribute");
+    }
+    for (const [property, value] of Object.entries(properties)) {
+        setStyleObjectProperty(expression, property, value);
+    }
+    return printMutationWithOperation(parsed.ast, source, {
+        kind: "update-style-properties",
+        target: "jsx-attribute",
+        inverse: "remove-style-properties",
+    });
+}
+function resolveStyleAttributeForUpdate(ast, locator, source) {
+    const attributeMatch = resolveOptionalJsxAttribute(ast, locator);
+    if (!attributeMatch.ok) {
+        return {
+            ok: false,
+            result: {
+                ok: false,
+                source,
+                diagnostic: attributeMatch.diagnostic,
+            },
+        };
+    }
+    if (attributeMatch.match) {
+        if (!attributeMatch.match.path.isJSXAttribute()) {
+            return {
+                ok: false,
+                result: primitiveFailure(source, "unsupported-syntax", "JSX locator must resolve to JSXAttribute", "jsx-attribute"),
+            };
+        }
+        return {
+            ok: true,
+            path: attributeMatch.match.path,
+        };
+    }
+    const elementMatch = resolveRequiredJsxElement(ast, locator.element, source);
+    if (!elementMatch.ok) {
+        return elementMatch;
+    }
+    const openingElementPath = elementMatch.match.path.get("openingElement");
+    openingElementPath.node.attributes.push(createJsxAttribute(locator.name, {}));
+    const attributes = openingElementPath.get("attributes");
+    const created = attributes[attributes.length - 1];
+    if (!created?.isJSXAttribute()) {
+        return {
+            ok: false,
+            result: primitiveFailure(source, "unsupported-syntax", "Failed to create JSX style attribute", "jsx-attribute"),
+        };
+    }
+    return { ok: true, path: created };
+}
+function setStyleObjectProperty(expression, property, value) {
+    const existing = expression
+        .get("properties")
+        .find((item) => item.isObjectProperty() &&
+        getStylePropertyKey(item.node.key) === property);
+    if (existing && existing.isObjectProperty()) {
+        existing.get("value").replaceWith(valueToExpression(value));
+    }
+    else {
+        expression.node.properties.push(objectProperty(objectPropertyKey(property), valueToExpression(value)));
+    }
+}
+export function updateCssModuleClassReference(params) {
+    const { source, locator, nextClass } = params;
+    const parsed = parseMutationSource(source, "jsx-attribute");
+    if (!parsed.ok) {
+        return parsed.result;
+    }
+    const attributeMatch = resolveRequiredJsxAttribute(parsed.ast, locator, source);
+    if (!attributeMatch.ok) {
+        return attributeMatch.result;
+    }
+    const attributePath = attributeMatch.match.path;
+    const valuePath = attributePath.get("value");
+    if (!valuePath.isJSXExpressionContainer()) {
+        return primitiveFailure(source, "unsupported-syntax", "CSS module className must use JSX expression container", "jsx-attribute");
+    }
+    const expression = valuePath.get("expression");
+    if (!expression.isMemberExpression() ||
+        expression.node.object.type !== "Identifier" ||
+        expression.node.object.name !== "styles") {
+        return primitiveFailure(source, "unsupported-syntax", "CSS module className must be styles.foo or styles['foo']", "jsx-attribute");
+    }
+    if (expression.node.computed) {
+        if (expression.node.property.type !== "StringLiteral") {
+            return primitiveFailure(source, "unsupported-syntax", "CSS module computed access must use string literal key", "jsx-attribute");
+        }
+        expression.node.property.value = nextClass;
+    }
+    else {
+        if (expression.node.property.type !== "Identifier") {
+            return primitiveFailure(source, "unsupported-syntax", "CSS module property access must use identifier key", "jsx-attribute");
+        }
+        expression.node.property.name = nextClass;
+    }
+    return printMutationWithOperation(parsed.ast, source, {
+        kind: "update-css-module-class",
+        target: "jsx-attribute",
+        inverse: "restore-css-module-class",
+    });
+}
+function mutateTailwindClassTokens(source, locator, mutate, strategy) {
+    const parsed = parseMutationSource(source, "jsx-attribute");
+    if (!parsed.ok) {
+        return parsed.result;
+    }
+    const attributeMatch = resolveRequiredJsxAttribute(parsed.ast, locator, source);
+    if (!attributeMatch.ok) {
+        return attributeMatch.result;
+    }
+    const currentValue = readStaticClassName(attributeMatch.match.path, source);
+    if (!currentValue.ok) {
+        const dynamicResult = mutateDynamicClassNameTokens(attributeMatch.match.path, source, mutate, strategy);
+        if (!dynamicResult.ok) {
+            return dynamicResult.result;
+        }
+        return printMutationWithOperation(parsed.ast, source, {
+            kind: "mutate-tailwind-class",
+            target: "jsx-attribute",
+            inverse: "restore-tailwind-class",
+        });
+    }
+    const tokens = new Set(currentValue.value.split(/\s+/).filter(Boolean));
+    mutate(tokens);
+    attributeMatch.match.path.node.value = createJsxAttribute(locator.name, [...tokens].join(" ")).value;
+    return printMutationWithOperation(parsed.ast, source, {
+        kind: "mutate-tailwind-class",
+        target: "jsx-attribute",
+        inverse: "restore-tailwind-class",
+    });
+}
+function updateDynamicClassName(params) {
+    const { source, locator, value } = params;
+    const parsed = parseMutationSource(source, "jsx-attribute");
+    if (!parsed.ok) {
+        return { handled: true, result: parsed.result };
+    }
+    const attributeMatch = resolveRequiredJsxAttribute(parsed.ast, locator, source);
+    if (!attributeMatch.ok) {
+        return { handled: false };
+    }
+    const attributePath = attributeMatch.match.path;
+    const valuePath = attributePath.get("value");
+    if (!valuePath.isJSXExpressionContainer()) {
+        return { handled: false };
+    }
+    const expression = valuePath.get("expression");
+    if (expression.isStringLiteral()) {
+        return { handled: false };
+    }
+    if (hasSpreadAfterAttribute(attributePath)) {
+        return {
+            handled: true,
+            result: primitiveFailure(source, "unsupported-syntax", "cannot edit explicit attribute when spread props follow it", "jsx-attribute"),
+        };
+    }
+    const analysis = analyzeClassExpression(expression);
+    if (!analysis.ok) {
+        expression.replaceWith(stringLiteral(value));
+        return {
+            handled: true,
+            result: printMutationWithOperation(parsed.ast, source, {
+                kind: "update-class-name",
+                target: "jsx-attribute",
+                inverse: "restore-class-name",
+            }),
+        };
+    }
+    if (analysis.mode === "class-map-reference") {
+        const classMapResult = mutateClassMapReference(expression, analysis, source, (valuePath) => {
+            valuePath.node.value = value;
+        });
+        if (!classMapResult.ok) {
+            return { handled: true, result: classMapResult.result };
+        }
+        return {
+            handled: true,
+            result: printMutationWithOperation(parsed.ast, source, {
+                kind: "update-class-name",
+                target: "jsx-attribute",
+                inverse: "restore-class-name",
+            }),
+        };
+    }
+    if (analysis.mode !== "call") {
+        return {
+            handled: true,
+            result: primitiveFailure(source, "unsupported-syntax", "className expression is not a supported class call", "jsx-attribute"),
+        };
+    }
+    if (!replaceFirstClassStringLiteral(expression, value)) {
+        return {
+            handled: true,
+            result: primitiveFailure(source, "unsupported-syntax", "className expression does not contain an editable string literal", "jsx-attribute"),
+        };
+    }
+    return {
+        handled: true,
+        result: printMutationWithOperation(parsed.ast, source, {
+            kind: "update-class-name",
+            target: "jsx-attribute",
+            inverse: "restore-class-name",
+        }),
+    };
+}
+function mutateDynamicClassNameTokens(attributePath, source, mutate, strategy) {
+    const valuePath = attributePath.get("value");
+    if (!valuePath.isJSXExpressionContainer()) {
+        return {
+            ok: false,
+            result: primitiveFailure(source, "unsupported-syntax", "Tailwind class editing only supports static className strings or class call expressions", "jsx-attribute"),
+        };
+    }
+    const expression = valuePath.get("expression");
+    const analysis = analyzeClassExpression(expression);
+    if (!analysis.ok) {
+        if (expression.isTemplateLiteral()) {
+            if (!mutateTemplateLiteralTokens(expression, mutate, strategy)) {
+                return {
+                    ok: false,
+                    result: primitiveFailure(source, "unsupported-syntax", "Template literal className does not contain editable static class tokens", "jsx-attribute"),
+                };
+            }
+            return { ok: true };
+        }
+        return {
+            ok: false,
+            result: diagnosticAsPrimitiveFailure(source, analysis.diagnostic),
+        };
+    }
+    if (analysis.mode === "class-map-reference") {
+        return mutateClassMapReference(expression, analysis, source, (valuePath) => {
+            mutateStringLiteralTokens(valuePath, mutate);
+        });
+    }
+    if (analysis.mode !== "call") {
+        return {
+            ok: false,
+            result: primitiveFailure(source, "unsupported-syntax", "Tailwind class editing only supports class call expressions at this stage", "jsx-attribute"),
+        };
+    }
+    const changed = mutateClassStringLiterals(expression, mutate, strategy);
+    if (changed === 0) {
+        return {
+            ok: false,
+            result: primitiveFailure(source, "unsupported-syntax", "Class call expression does not contain editable string literal class tokens", "jsx-attribute"),
+        };
+    }
+    return { ok: true };
+}
+function mutateClassStringLiterals(path, mutate, strategy) {
+    if (path.isStringLiteral()) {
+        mutateStringLiteralTokens(path, mutate);
+        return 1;
+    }
+    if (path.isConditionalExpression()) {
+        let changed = mutateClassStringLiterals(path.get("consequent"), mutate, strategy);
+        if (strategy === "first" && changed > 0)
+            return changed;
+        changed += mutateClassStringLiterals(path.get("alternate"), mutate, strategy);
+        return changed;
+    }
+    if (path.isCallExpression() && isSupportedClassCall(path.node)) {
+        let changed = 0;
+        for (const argument of path.get("arguments")) {
+            if (!argument.isExpression())
+                continue;
+            changed += mutateClassStringLiterals(argument, mutate, strategy);
+            if (strategy === "first" && changed > 0)
+                return changed;
+        }
+        return changed;
+    }
+    return 0;
+}
+function mutateTemplateLiteralTokens(path, mutate, strategy) {
+    let changed = false;
+    for (const quasi of path.node.quasis) {
+        const before = quasi.value.raw;
+        const tokens = new Set(before.split(/\s+/).filter(Boolean));
+        if (tokens.size === 0)
+            continue;
+        mutate(tokens);
+        const next = [...tokens].join(" ");
+        quasi.value.raw = next;
+        quasi.value.cooked = next;
+        changed = true;
+        if (strategy === "first")
+            break;
+    }
+    return changed;
+}
+function mutateClassMapReference(path, analysis, source, mutate) {
+    const objectName = analysis.segments.find((segment) => segment.objectName)?.objectName;
+    const keys = [
+        ...new Set(analysis.segments
+            .map((segment) => segment.key)
+            .filter((key) => Boolean(key))),
+    ];
+    if (!objectName || keys.length === 0) {
+        return {
+            ok: false,
+            result: primitiveFailure(source, "unsupported-syntax", "Class map reference is missing a static object name or key", "jsx-attribute"),
+        };
+    }
+    const binding = path.scope.getBinding(objectName);
+    const bindingPath = binding?.path;
+    if (!bindingPath?.isVariableDeclarator() ||
+        bindingPath.parent.type !== "VariableDeclaration" ||
+        bindingPath.parent.kind !== "const") {
+        return {
+            ok: false,
+            result: primitiveFailure(source, "unsupported-syntax", "Class map must reference a local const object literal", "jsx-attribute"),
+        };
+    }
+    const init = bindingPath.get("init");
+    if (!init?.isObjectExpression()) {
+        return {
+            ok: false,
+            result: primitiveFailure(source, "unsupported-syntax", "Class map binding must be an object literal", "jsx-attribute"),
+        };
+    }
+    for (const key of keys) {
+        const property = findClassMapStringProperty(init, key, source);
+        if (!property.ok) {
+            return property;
+        }
+        mutate(property.path);
+    }
+    return { ok: true };
+}
+function findClassMapStringProperty(objectPath, key, source) {
+    for (const property of objectPath.get("properties")) {
+        if (!property.isObjectProperty()) {
+            return {
+                ok: false,
+                result: primitiveFailure(source, "unsupported-syntax", "Class map object cannot contain spread properties or methods", "jsx-attribute"),
+            };
+        }
+        if (getStylePropertyKey(property.node.key) !== key)
+            continue;
+        const value = property.get("value");
+        if (!value.isStringLiteral()) {
+            return {
+                ok: false,
+                result: primitiveFailure(source, "unsupported-syntax", `Class map key "${key}" must resolve to a string literal`, "jsx-attribute"),
+            };
+        }
+        return { ok: true, path: value };
+    }
+    return {
+        ok: false,
+        result: primitiveFailure(source, "unsupported-syntax", `Class map key "${key}" was not found`, "jsx-attribute"),
+    };
+}
+function replaceFirstClassStringLiteral(path, value) {
+    if (path.isStringLiteral()) {
+        path.node.value = value;
+        return true;
+    }
+    if (path.isConditionalExpression()) {
+        return (replaceFirstClassStringLiteral(path.get("consequent"), value) ||
+            replaceFirstClassStringLiteral(path.get("alternate"), value));
+    }
+    if (path.isCallExpression() && isSupportedClassCall(path.node)) {
+        for (const argument of path.get("arguments")) {
+            if (argument.isExpression() &&
+                replaceFirstClassStringLiteral(argument, value)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function mutateStringLiteralTokens(path, mutate) {
+    const tokens = new Set(path.node.value.split(/\s+/).filter(Boolean));
+    mutate(tokens);
+    path.node.value = [...tokens].join(" ");
+}
+function hasSpreadAfterAttribute(path) {
+    const openingElement = path.parentPath;
+    if (!openingElement?.isJSXOpeningElement())
+        return false;
+    const index = openingElement.node.attributes.indexOf(path.node);
+    return openingElement.node.attributes.some((attribute, attributeIndex) => attributeIndex > index && attribute.type === "JSXSpreadAttribute");
+}
+function isSupportedClassCall(node) {
+    return (node.callee.type === "Identifier" &&
+        (node.callee.name === "cn" ||
+            node.callee.name === "clsx" ||
+            node.callee.name === "twMerge"));
+}
+function diagnosticAsPrimitiveFailure(source, diagnostic) {
+    return primitiveFailure(source, diagnostic.code, diagnostic.message, diagnostic.locatorKind, diagnostic.details);
+}
+function readStaticClassName(path, source) {
+    const valuePath = path.get("value");
+    if (valuePath.isStringLiteral()) {
+        return { ok: true, value: valuePath.node.value };
+    }
+    if (valuePath.isJSXExpressionContainer()) {
+        const expression = valuePath.get("expression");
+        if (expression.isStringLiteral()) {
+            return { ok: true, value: expression.node.value };
+        }
+    }
+    return {
+        ok: false,
+        result: primitiveFailure(source, "unsupported-syntax", "Tailwind class editing only supports static className strings", "jsx-attribute"),
+    };
+}
+function getStylePropertyKey(key) {
+    if (key.type === "Identifier") {
+        return key.name;
+    }
+    if (key.type === "StringLiteral") {
+        return key.value;
+    }
+    return null;
+}

package/dist/internal/ast/primitives/values/index.d.ts

@@ -0,0 +1 @@
+export { updateValue, insertArrayElement, removeArrayElement, moveArrayElement, insertObjectProperty, removeObjectProperty, type UpdateValueParams, type InsertArrayElementParams, type RemoveArrayElementParams, type MoveArrayElementParams, type InsertObjectPropertyParams, type RemoveObjectPropertyParams, } from "./value-primitives.js";

package/dist/internal/ast/primitives/values/index.js

@@ -0,0 +1 @@
+export { updateValue, insertArrayElement, removeArrayElement, moveArrayElement, insertObjectProperty, removeObjectProperty, } from "./value-primitives.js";

package/dist/internal/ast/primitives/values/value-primitives.d.ts

@@ -0,0 +1,42 @@
+import type { AstPrimitiveResult, PrimitiveValue, ValueLocator } from "../../types.js";
+export interface UpdateValueParams {
+    source: string;
+    locator: ValueLocator;
+    next: PrimitiveValue;
+}
+export interface InsertArrayElementParams {
+    source: string;
+    locator: ValueLocator;
+    index: number;
+    value: PrimitiveValue;
+}
+export interface RemoveArrayElementParams {
+    source: string;
+    locator: ValueLocator;
+    index: number;
+}
+export interface MoveArrayElementParams {
+    source: string;
+    locator: ValueLocator;
+    fromIndex: number;
+    toIndex: number;
+}
+export interface InsertObjectPropertyParams {
+    source: string;
+    locator: ValueLocator;
+    property: {
+        key: string;
+        value: PrimitiveValue;
+    };
+}
+export interface RemoveObjectPropertyParams {
+    source: string;
+    locator: ValueLocator;
+    key: string;
+}
+export declare function updateValue(params: UpdateValueParams): AstPrimitiveResult;
+export declare function insertArrayElement(params: InsertArrayElementParams): AstPrimitiveResult;
+export declare function removeArrayElement(params: RemoveArrayElementParams): AstPrimitiveResult;
+export declare function moveArrayElement(params: MoveArrayElementParams): AstPrimitiveResult;
+export declare function insertObjectProperty(params: InsertObjectPropertyParams): AstPrimitiveResult;
+export declare function removeObjectProperty(params: RemoveObjectPropertyParams): AstPrimitiveResult;