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

package/dist/internal/ast/primitives/shared.js

@@ -0,0 +1,176 @@
+import * as parser from "@babel/parser";
+import { arrayExpression, booleanLiteral, identifier, jsxAttribute, jsxExpressionContainer, jsxIdentifier, nullLiteral, numericLiteral, objectExpression, objectProperty, stringLiteral, } from "@babel/types";
+import { primitiveFailure } from "../diagnostics/index.js";
+import { parseForMutation } from "../parser/index.js";
+import { printAst } from "../printer/index.js";
+import { resolveLocatorPath, } from "../locators/index.js";
+// ---- Operation Builder ----
+function computeSourceHash(source) {
+    let hash = 0;
+    for (let i = 0; i < source.length; i++) {
+        const char = source.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash |= 0;
+    }
+    return `0x${Math.abs(hash).toString(16)}`;
+}
+export function buildOperationDescription(beforeSource, afterSource, params) {
+    return {
+        ok: true,
+        source: afterSource,
+        operation: {
+            type: params.kind,
+            nodeId: params.target,
+            kind: params.kind,
+            target: params.target,
+            beforeSourceHash: computeSourceHash(beforeSource),
+            afterSourceHash: computeSourceHash(afterSource),
+            inverse: params.inverse,
+        },
+    };
+}
+export function printMutationWithOperation(ast, beforeSource, params) {
+    const printResult = printAst({ ast, source: beforeSource });
+    if (!printResult.ok) {
+        return printResult;
+    }
+    return buildOperationDescription(beforeSource, printResult.source, params);
+}
+export function parseMutationSource(source, locatorKind) {
+    const parsed = parseForMutation(source, locatorKind);
+    if (!parsed.ok) {
+        return {
+            ok: false,
+            result: {
+                ok: false,
+                source,
+                diagnostic: parsed.diagnostic,
+            },
+        };
+    }
+    return {
+        ok: true,
+        ast: parsed.ast,
+    };
+}
+export function printMutation(ast, source) {
+    return printAst({ ast, source });
+}
+export function resolveRequiredJsxNode(ast, locator, source) {
+    const result = resolveLocatorPath(ast, locator);
+    if (!result.ok) {
+        return {
+            ok: false,
+            result: {
+                ok: false,
+                source,
+                diagnostic: result.diagnostic,
+            },
+        };
+    }
+    return { ok: true, match: result.match };
+}
+export function resolveRequiredJsxElement(ast, locator, source) {
+    const result = resolveRequiredJsxNode(ast, locator, source);
+    if (!result.ok) {
+        return result;
+    }
+    if (!result.match.path.isJSXElement()) {
+        return {
+            ok: false,
+            result: primitiveFailure(source, "unsupported-syntax", "JSX locator must resolve to JSXElement", "jsx-node"),
+        };
+    }
+    return result;
+}
+export function resolveRequiredJsxAttribute(ast, locator, source) {
+    const result = resolveLocatorPath(ast, locator);
+    if (!result.ok) {
+        return {
+            ok: false,
+            result: {
+                ok: false,
+                source,
+                diagnostic: result.diagnostic,
+            },
+        };
+    }
+    if (!result.match.path.isJSXAttribute()) {
+        return {
+            ok: false,
+            result: primitiveFailure(source, "unsupported-syntax", "JSX locator must resolve to JSXAttribute", "jsx-attribute"),
+        };
+    }
+    return { ok: true, match: result.match };
+}
+export function resolveOptionalJsxAttribute(ast, locator) {
+    const result = resolveLocatorPath(ast, locator);
+    if (result.ok) {
+        return { ok: true, match: result.match };
+    }
+    if (result.diagnostic.code === "locator-miss") {
+        return { ok: true, match: null };
+    }
+    return { ok: false, diagnostic: result.diagnostic };
+}
+export function valueToExpression(value) {
+    if (typeof value === "string") {
+        return stringLiteral(value);
+    }
+    if (typeof value === "number") {
+        return numericLiteral(value);
+    }
+    if (typeof value === "boolean") {
+        return booleanLiteral(value);
+    }
+    if (value === null) {
+        return nullLiteral();
+    }
+    if (Array.isArray(value)) {
+        return arrayExpression(value.map((item) => valueToExpression(item)));
+    }
+    return objectExpression(Object.entries(value).map(([key, item]) => objectProperty(identifier(key), valueToExpression(item))));
+}
+export function valueToJsxAttributeValue(value) {
+    if (typeof value === "string") {
+        return stringLiteral(value);
+    }
+    return jsxExpressionContainer(valueToExpression(value));
+}
+export function createJsxAttribute(name, value) {
+    return jsxAttribute(jsxIdentifier(name), valueToJsxAttributeValue(value));
+}
+export function parseJsxNodeSource(source, jsx) {
+    try {
+        const ast = parser.parse(`const __VD_NODE__ = (${jsx});`, {
+            sourceType: "module",
+            plugins: ["jsx", "typescript"],
+        });
+        const declaration = ast.program.body[0];
+        if (declaration?.type !== "VariableDeclaration" ||
+            declaration.declarations[0]?.type !== "VariableDeclarator" ||
+            !declaration.declarations[0].init ||
+            (declaration.declarations[0].init.type !== "JSXElement" &&
+                declaration.declarations[0].init.type !== "JSXFragment")) {
+            return {
+                ok: false,
+                result: primitiveFailure(source, "unsupported-syntax", "Provided JSX source does not resolve to a JSX node", "jsx-node"),
+            };
+        }
+        return {
+            ok: true,
+            node: declaration.declarations[0].init,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            result: primitiveFailure(source, "parse-failed", `AST parse failed: ${error instanceof Error ? error.message : String(error)}`, "jsx-node"),
+        };
+    }
+}
+export function objectPropertyKey(name) {
+    return /^[$A-Z_][0-9A-Z_$]*$/i.test(name)
+        ? identifier(name)
+        : stringLiteral(name);
+}

package/dist/internal/ast/primitives/style/class-expression.d.ts

@@ -0,0 +1,23 @@
+import type { NodePath } from "@babel/traverse";
+import type * as t from "@babel/types";
+import type { AstDiagnostic } from "../../types.js";
+export type ClassExpressionMode = "static" | "call" | "class-map-reference";
+export type ClassExpressionSegmentRole = "static" | "conditional-consequent" | "conditional-alternate" | "object-boolean" | "class-map";
+export interface ClassExpressionSegment {
+    role: ClassExpressionSegmentRole;
+    value: string;
+    key?: string;
+    objectName?: string;
+}
+export type ClassExpressionAnalysis = {
+    ok: true;
+    mode: ClassExpressionMode;
+    calls: string[];
+    segments: ClassExpressionSegment[];
+} | {
+    ok: false;
+    diagnostic: AstDiagnostic;
+};
+type ExpressionPath = NodePath<t.Expression | t.JSXEmptyExpression>;
+export declare function analyzeClassExpression(path: ExpressionPath): ClassExpressionAnalysis;
+export {};

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

@@ -0,0 +1,174 @@
+import { createDiagnostic } from "../../diagnostics/index.js";
+export function analyzeClassExpression(path) {
+    if (path.isStringLiteral()) {
+        return success("static", [], [{ role: "static", value: path.node.value }]);
+    }
+    const classMap = analyzeClassMapReference(path);
+    if (classMap.ok) {
+        return classMap;
+    }
+    if (path.isConditionalExpression()) {
+        return analyzeClassArgument(path, "static");
+    }
+    if (path.isCallExpression()) {
+        return analyzeClassCall(path);
+    }
+    return unsupported("Class expression must be a static string, clsx/twMerge call, or local class map reference");
+}
+function analyzeClassCall(path) {
+    const callee = callName(path.node.callee);
+    if (!isSupportedClassCallName(callee)) {
+        return unsupported("Class call expression must use cn(), clsx(), or twMerge()");
+    }
+    const calls = [callee];
+    const segments = [];
+    for (const argument of path.get("arguments")) {
+        if (!argument.isExpression()) {
+            return unsupported("Class call arguments must be expressions");
+        }
+        const analyzed = analyzeClassArgument(argument, "static");
+        if (!analyzed.ok) {
+            return analyzed;
+        }
+        calls.push(...analyzed.calls);
+        segments.push(...analyzed.segments);
+    }
+    return success("call", unique(calls), segments);
+}
+function analyzeClassArgument(path, role) {
+    if (path.isStringLiteral()) {
+        return success("static", [], [{ role, value: path.node.value }]);
+    }
+    if (path.isConditionalExpression()) {
+        const consequent = path.get("consequent");
+        const alternate = path.get("alternate");
+        const consequentResult = analyzeClassArgument(consequent, "conditional-consequent");
+        if (!consequentResult.ok)
+            return consequentResult;
+        const alternateResult = analyzeClassArgument(alternate, "conditional-alternate");
+        if (!alternateResult.ok)
+            return alternateResult;
+        return success("call", unique([...consequentResult.calls, ...alternateResult.calls]), [...consequentResult.segments, ...alternateResult.segments]);
+    }
+    if (path.isObjectExpression()) {
+        const segments = [];
+        for (const property of path.node.properties) {
+            if (property.type !== "ObjectProperty") {
+                return unsupported("Class object arguments cannot contain spreads or methods");
+            }
+            const key = objectPropertyKey(property.key);
+            if (!key) {
+                return unsupported("Class object keys must be static identifiers or strings");
+            }
+            segments.push({ role: "object-boolean", value: key, key });
+        }
+        return success("call", [], segments);
+    }
+    const classMap = analyzeClassMapReference(path);
+    if (classMap.ok) {
+        return classMap;
+    }
+    if (path.isCallExpression()) {
+        return analyzeClassCall(path);
+    }
+    return unsupported("Class argument is not statically analyzable");
+}
+function analyzeClassMapReference(path) {
+    if (!path.isMemberExpression()) {
+        return unsupported("Not a class map reference");
+    }
+    const object = path.get("object");
+    if (!object.isIdentifier()) {
+        return unsupported("Class map object must be an identifier");
+    }
+    const keys = memberExpressionKeys(path);
+    if (keys.length === 0) {
+        return unsupported("Class map key must be statically resolvable");
+    }
+    const binding = path.scope.getBinding(object.node.name);
+    const bindingPath = binding?.path;
+    if (!bindingPath?.isVariableDeclarator()) {
+        return unsupported("Class map must reference a local const object literal");
+    }
+    if (bindingPath.parent.type !== "VariableDeclaration" ||
+        bindingPath.parent.kind !== "const") {
+        return unsupported("Class map must reference a local const object literal");
+    }
+    const init = bindingPath.get("init");
+    if (!init?.isObjectExpression()) {
+        return unsupported("Class map binding must be an object literal");
+    }
+    const segments = [];
+    for (const key of keys) {
+        const value = objectExpressionStringValue(init.node, key);
+        if (value === null) {
+            return unsupported(`Class map key "${key}" must resolve to a string literal`);
+        }
+        segments.push({
+            role: "class-map",
+            value,
+            key,
+            objectName: object.node.name,
+        });
+    }
+    return success("class-map-reference", [], segments);
+}
+function memberExpressionKeys(path) {
+    if (!path.node.computed && path.node.property.type === "Identifier") {
+        return [path.node.property.name];
+    }
+    const property = path.get("property");
+    if (property.isStringLiteral()) {
+        return [property.node.value];
+    }
+    if (property.isConditionalExpression()) {
+        const consequent = property.get("consequent");
+        const alternate = property.get("alternate");
+        if (consequent.isStringLiteral() && alternate.isStringLiteral()) {
+            return [consequent.node.value, alternate.node.value];
+        }
+    }
+    return [];
+}
+function objectExpressionStringValue(object, key) {
+    for (const property of object.properties) {
+        if (property.type !== "ObjectProperty")
+            continue;
+        if (objectPropertyKey(property.key) !== key)
+            continue;
+        if (property.value.type !== "StringLiteral")
+            return null;
+        return property.value.value;
+    }
+    return null;
+}
+function objectPropertyKey(key) {
+    if (key.type === "Identifier")
+        return key.name;
+    if (key.type === "StringLiteral")
+        return key.value;
+    return null;
+}
+function callName(callee) {
+    return callee.type === "Identifier" ? callee.name : null;
+}
+function isSupportedClassCallName(name) {
+    return name === "cn" || name === "clsx" || name === "twMerge";
+}
+function success(mode, calls, segments) {
+    return {
+        ok: true,
+        mode,
+        calls,
+        segments,
+    };
+}
+function unsupported(message) {
+    return {
+        ok: false,
+        diagnostic: createDiagnostic("unsupported-syntax", message, "jsx-attribute"),
+    };
+}
+function unique(items) {
+    return [...new Set(items)];
+}

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

@@ -0,0 +1 @@
+export { setJsxAttribute, removeJsxAttribute, updateClassName, addTailwindClass, removeTailwindClass, updateStyleProperty, updateStyleProperties, updateCssModuleClassReference, type SetJsxAttributeParams, type RemoveJsxAttributeParams, type UpdateClassNameParams, type AddTailwindClassParams, type RemoveTailwindClassParams, type UpdateStylePropertyParams, type UpdateStylePropertiesParams, type UpdateCssModuleClassReferenceParams, } from "./style-primitives.js";

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

@@ -0,0 +1 @@
+export { setJsxAttribute, removeJsxAttribute, updateClassName, addTailwindClass, removeTailwindClass, updateStyleProperty, updateStyleProperties, updateCssModuleClassReference, } from "./style-primitives.js";

package/dist/internal/ast/primitives/style/style-primitives.d.ts

@@ -0,0 +1,49 @@
+import type { AstPrimitiveResult, JsxAttributeLocator, PrimitiveValue } from "../../types.js";
+export interface SetJsxAttributeParams {
+    source: string;
+    locator: JsxAttributeLocator;
+    value: PrimitiveValue;
+}
+export interface RemoveJsxAttributeParams {
+    source: string;
+    locator: JsxAttributeLocator;
+}
+export interface UpdateClassNameParams {
+    source: string;
+    locator: JsxAttributeLocator;
+    value: string;
+}
+export interface AddTailwindClassParams {
+    source: string;
+    locator: JsxAttributeLocator;
+    token: string;
+}
+export interface RemoveTailwindClassParams {
+    source: string;
+    locator: JsxAttributeLocator;
+    token: string;
+}
+export interface UpdateStylePropertyParams {
+    source: string;
+    locator: JsxAttributeLocator;
+    property: string;
+    value: PrimitiveValue;
+}
+export interface UpdateStylePropertiesParams {
+    source: string;
+    locator: JsxAttributeLocator;
+    properties: Record<string, PrimitiveValue>;
+}
+export interface UpdateCssModuleClassReferenceParams {
+    source: string;
+    locator: JsxAttributeLocator;
+    nextClass: string;
+}
+export declare function setJsxAttribute(params: SetJsxAttributeParams): AstPrimitiveResult;
+export declare function removeJsxAttribute(params: RemoveJsxAttributeParams): AstPrimitiveResult;
+export declare function updateClassName(params: UpdateClassNameParams): AstPrimitiveResult;
+export declare function addTailwindClass(params: AddTailwindClassParams): AstPrimitiveResult;
+export declare function removeTailwindClass(params: RemoveTailwindClassParams): AstPrimitiveResult;
+export declare function updateStyleProperty(params: UpdateStylePropertyParams): AstPrimitiveResult;
+export declare function updateStyleProperties(params: UpdateStylePropertiesParams): AstPrimitiveResult;
+export declare function updateCssModuleClassReference(params: UpdateCssModuleClassReferenceParams): AstPrimitiveResult;