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

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

@@ -0,0 +1,10 @@
+export { updateText } from "./jsx/index.js";
+export { removeNode } from "./jsx/index.js";
+export { insertChild } from "./jsx/index.js";
+export { moveNode } from "./jsx/index.js";
+export { addImport, } from "./imports/index.js";
+export { removeImport, } from "./imports/index.js";
+export { updateValue, insertArrayElement, removeArrayElement, moveArrayElement, insertObjectProperty, removeObjectProperty, } from "./values/index.js";
+export { replaceConditionalExpression, setConditionalBranchContent, } from "./conditional/index.js";
+export { addDirective, removeDirective, updateDirective, updateNamedExport, updateMetadataField, updateGenerateMetadata, } from "./next/index.js";
+export { setJsxAttribute, removeJsxAttribute, updateClassName, addTailwindClass, removeTailwindClass, updateStyleProperty, updateStyleProperties, updateCssModuleClassReference, } from "./style/index.js";

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

@@ -0,0 +1,4 @@
+export { updateText, type UpdateTextParams } from "./update-text.js";
+export { removeNode, type RemoveNodeParams } from "./remove-node.js";
+export { insertChild, type InsertChildParams } from "./insert-child.js";
+export { moveNode, type MoveNodeParams } from "./move-node.js";

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

@@ -0,0 +1,4 @@
+export { updateText } from "./update-text.js";
+export { removeNode } from "./remove-node.js";
+export { insertChild } from "./insert-child.js";
+export { moveNode } from "./move-node.js";

package/dist/internal/ast/primitives/jsx/insert-child.d.ts

@@ -0,0 +1,11 @@
+import type { AstPrimitiveResult, JsxNodeLocator, Placement } from "../../types.js";
+export interface InsertChildParams {
+    source: string;
+    locator: JsxNodeLocator;
+    node: {
+        jsx: string;
+    };
+    placement: Placement;
+    anchorLocator?: JsxNodeLocator;
+}
+export declare function insertChild(params: InsertChildParams): AstPrimitiveResult;

package/dist/internal/ast/primitives/jsx/insert-child.js

@@ -0,0 +1,69 @@
+import { cloneNode, } from "@babel/types";
+import { primitiveFailure } from "../../diagnostics/index.js";
+import { resolveLocatorPath } from "../../locators/index.js";
+import { parseJsxNodeSource, parseMutationSource, printMutationWithOperation, } from "../shared.js";
+export function insertChild(params) {
+    const { source, locator, node, placement, anchorLocator } = params;
+    const parsed = parseMutationSource(source, "jsx-node");
+    /* node:coverage ignore start */
+    if (!parsed.ok) {
+        return parsed.result;
+    }
+    /* node:coverage ignore stop */
+    const parentMatch = resolveLocatorPath(parsed.ast, locator);
+    if (!parentMatch.ok) {
+        return { ok: false, source, diagnostic: parentMatch.diagnostic };
+    }
+    const parentNode = parentMatch.match.path.node;
+    if (!parentMatch.match.path.isJSXElement() &&
+        !parentMatch.match.path.isJSXFragment()) {
+        return primitiveFailure(source, "unsupported-syntax", "insert-child target must be a JSXElement or JSXFragment", "jsx-node");
+    }
+    if (parentMatch.match.path.isJSXElement()) {
+        if (!parentNode.closingElement || parentNode.openingElement.selfClosing) {
+            return primitiveFailure(source, "self-closing-element", "Cannot insert child into self-closing element", "jsx-node");
+        }
+    }
+    const parsedNode = parseJsxNodeSource(source, node.jsx);
+    if (!parsedNode.ok) {
+        return parsedNode.result;
+    }
+    const nextChild = cloneNode(parsedNode.node, true);
+    const children = parentNode.children;
+    if (placement === "append") {
+        children.push(nextChild);
+        return printMutationWithOperation(parsed.ast, source, {
+            kind: "insert-child",
+            target: "jsx-node",
+            inverse: "remove-child",
+        });
+    }
+    if (placement === "prepend") {
+        children.unshift(nextChild);
+        return printMutationWithOperation(parsed.ast, source, {
+            kind: "insert-child",
+            target: "jsx-node",
+            inverse: "remove-child",
+        });
+    }
+    if (!anchorLocator) {
+        return primitiveFailure(source, "locator-miss", `Placement '${placement}' requires anchorLocator`, "jsx-node");
+    }
+    const anchorMatch = resolveLocatorPath(parsed.ast, anchorLocator);
+    if (!anchorMatch.ok)
+        return { ok: false, source, diagnostic: anchorMatch.diagnostic };
+    if (anchorMatch.match.path.parentPath !== parentMatch.match.path ||
+        anchorMatch.match.path.listKey !== "children") {
+        return primitiveFailure(source, "invalid-parent-child-relation", "Anchor node is not a direct child of the target parent", "jsx-node");
+    }
+    const anchorIndex = children.findIndex((child) => child === anchorMatch.match.path.node);
+    if (anchorIndex === -1) {
+        return primitiveFailure(source, "locator-miss", "Anchor node no longer exists in target parent", "jsx-node");
+    }
+    children.splice(placement === "before" ? anchorIndex : anchorIndex + 1, 0, nextChild);
+    return printMutationWithOperation(parsed.ast, source, {
+        kind: "insert-child",
+        target: "jsx-node",
+        inverse: "remove-child",
+    });
+}

package/dist/internal/ast/primitives/jsx/move-node.d.ts

@@ -0,0 +1,9 @@
+import type { AstPrimitiveResult, JsxNodeLocator, Placement } from "../../types.js";
+export interface MoveNodeParams {
+    source: string;
+    locator: JsxNodeLocator;
+    targetParentLocator: JsxNodeLocator;
+    placement: Placement;
+    anchorLocator?: JsxNodeLocator;
+}
+export declare function moveNode(params: MoveNodeParams): AstPrimitiveResult;

package/dist/internal/ast/primitives/jsx/move-node.js

@@ -0,0 +1,76 @@
+import { cloneNode, nullLiteral } from "@babel/types";
+import { primitiveFailure } from "../../diagnostics/index.js";
+import { resolveLocatorPath } from "../../locators/index.js";
+import { parseMutationSource, printMutation } from "../shared.js";
+export function moveNode(params) {
+    const { source, locator, targetParentLocator, placement, anchorLocator } = params;
+    const parsed = parseMutationSource(source, "jsx-node");
+    if (!parsed.ok) {
+        return parsed.result;
+    }
+    const sourceMatch = resolveLocatorPath(parsed.ast, locator);
+    if (!sourceMatch.ok) {
+        return { ok: false, source, diagnostic: sourceMatch.diagnostic };
+    }
+    const targetParentMatch = resolveLocatorPath(parsed.ast, targetParentLocator);
+    if (!targetParentMatch.ok) {
+        return { ok: false, source, diagnostic: targetParentMatch.diagnostic };
+    }
+    if (!targetParentMatch.match.path.isJSXElement()) {
+        return primitiveFailure(source, "unsupported-syntax", "move-node target parent must be a JSXElement", "jsx-node");
+    }
+    const targetParent = targetParentMatch.match.path.node;
+    if (!targetParent.closingElement || targetParent.openingElement.selfClosing) {
+        return primitiveFailure(source, "self-closing-element", "Cannot move child into self-closing element", "jsx-node");
+    }
+    let anchorNode = null;
+    if (!anchorLocator) {
+        if (placement === "before" || placement === "after") {
+            return primitiveFailure(source, "locator-miss", `Placement '${placement}' requires anchorLocator`, "jsx-node");
+        }
+    }
+    else {
+        const anchorMatch = resolveLocatorPath(parsed.ast, anchorLocator);
+        if (!anchorMatch.ok) {
+            return { ok: false, source, diagnostic: anchorMatch.diagnostic };
+        }
+        if (anchorMatch.match.path.parentPath !== targetParentMatch.match.path ||
+            anchorMatch.match.path.listKey !== "children") {
+            return primitiveFailure(source, "invalid-parent-child-relation", "Anchor node is not a direct child of the target parent", "jsx-node");
+        }
+        anchorNode = anchorMatch.match.path.node;
+    }
+    const movingNode = cloneNode(sourceMatch.match.path.node, true);
+    removeMovedJsxNodePath(sourceMatch.match.path);
+    const children = targetParent.children;
+    if (placement === "append") {
+        children.push(movingNode);
+        return printMutation(parsed.ast, source);
+    }
+    if (placement === "prepend") {
+        children.unshift(movingNode);
+        return printMutation(parsed.ast, source);
+    }
+    const anchorIndex = children.findIndex((child) => child === anchorNode);
+    if (anchorIndex === -1) {
+        return primitiveFailure(source, "locator-miss", "Anchor node no longer exists in target parent", "jsx-node");
+    }
+    children.splice(placement === "before" ? anchorIndex : anchorIndex + 1, 0, movingNode);
+    return printMutation(parsed.ast, source);
+}
+function removeMovedJsxNodePath(path) {
+    if (path.parentPath?.isConditionalExpression() &&
+        (path.key === "consequent" || path.key === "alternate")) {
+        path.replaceWith(nullLiteral());
+        return;
+    }
+    if (path.parentPath?.isArrowFunctionExpression() && path.key === "body") {
+        path.replaceWith(nullLiteral());
+        return;
+    }
+    if (path.parentPath?.isReturnStatement() && path.key === "argument") {
+        path.replaceWith(nullLiteral());
+        return;
+    }
+    path.remove();
+}

package/dist/internal/ast/primitives/jsx/remove-node.d.ts

@@ -0,0 +1,7 @@
+import type { AstPrimitiveResult, JsxNodeLocator } from "../../types.js";
+export interface RemoveNodeParams {
+    source: string;
+    locator: JsxNodeLocator;
+    removeWhitespace?: boolean;
+}
+export declare function removeNode(params: RemoveNodeParams): AstPrimitiveResult;

package/dist/internal/ast/primitives/jsx/remove-node.js

@@ -0,0 +1,36 @@
+import { nullLiteral } from "@babel/types";
+import { resolveLocatorPath } from "../../locators/index.js";
+import { parseMutationSource, printMutationWithOperation } from "../shared.js";
+export function removeNode(params) {
+    const { source, locator } = params;
+    const parsed = parseMutationSource(source, "jsx-node");
+    if (!parsed.ok) {
+        return parsed.result;
+    }
+    const match = resolveLocatorPath(parsed.ast, locator);
+    if (!match.ok) {
+        return { ok: false, source, diagnostic: match.diagnostic };
+    }
+    removeJsxNodePathSafely(match.match.path);
+    return printMutationWithOperation(parsed.ast, source, {
+        kind: "remove-node",
+        target: "jsx-node",
+        inverse: "insert-child",
+    });
+}
+function removeJsxNodePathSafely(path) {
+    if (path.parentPath?.isConditionalExpression() &&
+        (path.key === "consequent" || path.key === "alternate")) {
+        path.replaceWith(nullLiteral());
+        return;
+    }
+    if (path.parentPath?.isArrowFunctionExpression() && path.key === "body") {
+        path.replaceWith(nullLiteral());
+        return;
+    }
+    if (path.parentPath?.isReturnStatement() && path.key === "argument") {
+        path.replaceWith(nullLiteral());
+        return;
+    }
+    path.remove();
+}

package/dist/internal/ast/primitives/jsx/update-text.d.ts

@@ -0,0 +1,8 @@
+import type { AstPrimitiveResult, JsxNodeLocator } from "../../types.js";
+export interface UpdateTextParams {
+    source: string;
+    locator: JsxNodeLocator;
+    segmentIndex: number;
+    newText: string;
+}
+export declare function updateText(params: UpdateTextParams): AstPrimitiveResult;

package/dist/internal/ast/primitives/jsx/update-text.js

@@ -0,0 +1,81 @@
+import { primitiveFailure } from "../../diagnostics/index.js";
+import { resolveLocatorPath } from "../../locators/index.js";
+import { parseMutationSource, printMutationWithOperation } from "../shared.js";
+export function updateText(params) {
+    const { source, locator, segmentIndex, newText } = params;
+    const parsed = parseMutationSource(source, "jsx-node");
+    if (!parsed.ok) {
+        return parsed.result;
+    }
+    const match = resolveLocatorPath(parsed.ast, locator);
+    if (!match.ok) {
+        return { ok: false, source, diagnostic: match.diagnostic };
+    }
+    const segments = collectTextSegments(match.match.path);
+    const segment = segments[segmentIndex];
+    if (!segment) {
+        return primitiveFailure(source, "locator-miss", `Text segment ${segmentIndex} not found`, "jsx-node");
+    }
+    switch (segment.kind) {
+        case "jsx-text":
+            segment.path.node.value = newText;
+            break;
+        case "string-literal":
+            segment.path.node.value = newText;
+            break;
+        case "template-literal": {
+            const quasiIndex = segment.quasiIndex;
+            segment.path.node.quasis[quasiIndex].value.raw = newText;
+            segment.path.node.quasis[quasiIndex].value.cooked = newText;
+            break;
+        }
+    }
+    return printMutationWithOperation(parsed.ast, source, {
+        kind: "update-text",
+        target: "jsx-node",
+        inverse: "restore-text",
+    });
+}
+function collectTextSegments(path) {
+    const segments = [];
+    path.traverse({
+        JSXText(textPath) {
+            if (textPath.node.value.trim().length > 0) {
+                segments.push({ kind: "jsx-text", path: textPath });
+            }
+        },
+        JSXExpressionContainer(containerPath) {
+            const segs = resolveExpressionTextSegments(containerPath.get("expression"));
+            if (segs.length > 0) {
+                segments.push(...segs);
+            }
+        },
+    });
+    return segments;
+}
+function resolveExpressionTextSegments(expression) {
+    if (expression.isStringLiteral()) {
+        return [{ kind: "string-literal", path: expression }];
+    }
+    if (expression.isTemplateLiteral()) {
+        const segments = [];
+        const quasis = expression.node.quasis;
+        for (let i = 0; i < quasis.length; i++) {
+            const quasi = quasis[i];
+            if (quasi.value.raw.trim().length > 0) {
+                segments.push({
+                    kind: "template-literal",
+                    path: expression,
+                    quasiIndex: i,
+                });
+            }
+        }
+        if (segments.length > 0) {
+            return segments;
+        }
+    }
+    if (!expression.isCallExpression()) {
+        return [];
+    }
+    return [];
+}

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

@@ -0,0 +1 @@
+export { addDirective, removeDirective, updateDirective, updateNamedExport, updateMetadataField, updateGenerateMetadata, type AddDirectiveParams, type RemoveDirectiveParams, type UpdateDirectiveParams, type UpdateNamedExportParams, type UpdateMetadataFieldParams, type UpdateGenerateMetadataParams, } from "./next-primitives.js";

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

@@ -0,0 +1 @@
+export { addDirective, removeDirective, updateDirective, updateNamedExport, updateMetadataField, updateGenerateMetadata, } from "./next-primitives.js";

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

@@ -0,0 +1,43 @@
+import type { AstPrimitiveResult, DirectiveLocator, ExportLocator, PrimitiveValue, ValuePathSegment } from "../../types.js";
+export interface AddDirectiveParams {
+    source: string;
+    value: string;
+}
+export interface RemoveDirectiveParams {
+    source: string;
+    locator: DirectiveLocator;
+}
+export interface UpdateDirectiveParams {
+    source: string;
+    locator: DirectiveLocator;
+    nextValue: string;
+}
+export interface UpdateNamedExportParams {
+    source: string;
+    locator: Extract<ExportLocator, {
+        exportKind: "named";
+    }>;
+    next: PrimitiveValue;
+}
+export interface UpdateMetadataFieldParams {
+    source: string;
+    locator: Extract<ExportLocator, {
+        exportKind: "metadata";
+    }>;
+    path: ValuePathSegment[];
+    next: PrimitiveValue;
+}
+export interface UpdateGenerateMetadataParams {
+    source: string;
+    locator: Extract<ExportLocator, {
+        exportKind: "generate-metadata";
+    }>;
+    path: ValuePathSegment[];
+    next: PrimitiveValue;
+}
+export declare function addDirective(params: AddDirectiveParams): AstPrimitiveResult;
+export declare function removeDirective(params: RemoveDirectiveParams): AstPrimitiveResult;
+export declare function updateDirective(params: UpdateDirectiveParams): AstPrimitiveResult;
+export declare function updateNamedExport(params: UpdateNamedExportParams): AstPrimitiveResult;
+export declare function updateMetadataField(params: UpdateMetadataFieldParams): AstPrimitiveResult;
+export declare function updateGenerateMetadata(params: UpdateGenerateMetadataParams): AstPrimitiveResult;

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

@@ -0,0 +1,211 @@
+import { directive, directiveLiteral } from "@babel/types";
+import { primitiveFailure } from "../../diagnostics/index.js";
+import { resolveLocatorPath } from "../../locators/index.js";
+import { parseMutationSource, printMutationWithOperation, valueToExpression, } from "../shared.js";
+export function addDirective(params) {
+    const { source, value } = params;
+    const parsed = parseMutationSource(source, "directive");
+    if (!parsed.ok) {
+        return parsed.result;
+    }
+    const conflict = conflictingDirective(value);
+    if (conflict &&
+        parsed.ast.program.directives.some((item) => item.value.value === conflict)) {
+        return primitiveFailure(source, "directive-conflict", `Directive '${value}' conflicts with '${conflict}'`, "directive");
+    }
+    if (!parsed.ast.program.directives.some((item) => item.value.value === value)) {
+        parsed.ast.program.directives.unshift(directive(directiveLiteral(value)));
+    }
+    return printMutationWithOperation(parsed.ast, source, {
+        kind: "add-directive",
+        target: "directive",
+        inverse: "remove-directive",
+    });
+}
+export function removeDirective(params) {
+    const { source, locator } = params;
+    const parsed = parseMutationSource(source, "directive");
+    if (!parsed.ok) {
+        return parsed.result;
+    }
+    const resolved = resolveLocatorPath(parsed.ast, locator);
+    if (!resolved.ok) {
+        return { ok: false, source, diagnostic: resolved.diagnostic };
+    }
+    resolved.match.path.remove();
+    return printMutationWithOperation(parsed.ast, source, {
+        kind: "remove-directive",
+        target: "directive",
+        inverse: "add-directive",
+    });
+}
+export function updateDirective(params) {
+    const { source, locator, nextValue } = params;
+    const parsed = parseMutationSource(source, "directive");
+    if (!parsed.ok) {
+        return parsed.result;
+    }
+    const conflict = conflictingDirective(nextValue);
+    if (conflict &&
+        parsed.ast.program.directives.some((item) => item.value.value === conflict && item.value.value !== locator.value)) {
+        return primitiveFailure(source, "directive-conflict", `Directive '${nextValue}' conflicts with '${conflict}'`, "directive");
+    }
+    const resolved = resolveLocatorPath(parsed.ast, locator);
+    if (!resolved.ok) {
+        return { ok: false, source, diagnostic: resolved.diagnostic };
+    }
+    resolved.match.path.node.value.value = nextValue;
+    return printMutationWithOperation(parsed.ast, source, {
+        kind: "update-directive",
+        target: "directive",
+        inverse: "restore-directive",
+    });
+}
+export function updateNamedExport(params) {
+    const { source, locator, next } = params;
+    const parsed = parseMutationSource(source, "export");
+    if (!parsed.ok) {
+        return parsed.result;
+    }
+    const resolved = resolveLocatorPath(parsed.ast, locator);
+    if (!resolved.ok) {
+        return { ok: false, source, diagnostic: resolved.diagnostic };
+    }
+    resolved.match.path.replaceWith(valueToExpression(next));
+    return printMutationWithOperation(parsed.ast, source, {
+        kind: "update-named-export",
+        target: "export",
+        inverse: "restore-named-export",
+    });
+}
+export function updateMetadataField(params) {
+    const { source, locator, path, next } = params;
+    const parsed = parseMutationSource(source, "export");
+    if (!parsed.ok) {
+        return parsed.result;
+    }
+    const resolved = resolveLocatorPath(parsed.ast, locator);
+    if (!resolved.ok) {
+        return { ok: false, source, diagnostic: resolved.diagnostic };
+    }
+    if (!resolved.match.path.isObjectExpression()) {
+        return primitiveFailure(source, "metadata-shape-unsupported", "metadata export must be a static object literal", "export");
+    }
+    const target = resolveMetadataObjectPath(resolved.match.path, path, source);
+    if (!target.ok) {
+        return target.result;
+    }
+    target.path.replaceWith(valueToExpression(next));
+    return printMutationWithOperation(parsed.ast, source, {
+        kind: "update-metadata-field",
+        target: "export",
+        inverse: "restore-metadata-field",
+    });
+}
+export function updateGenerateMetadata(params) {
+    const { source, locator, path, next } = params;
+    const parsed = parseMutationSource(source, "export");
+    if (!parsed.ok) {
+        return parsed.result;
+    }
+    const resolved = resolveLocatorPath(parsed.ast, locator);
+    if (!resolved.ok) {
+        return { ok: false, source, diagnostic: resolved.diagnostic };
+    }
+    const node = resolved.match.path.node;
+    const isFunctionDecl = resolved.match.path.isFunctionDeclaration();
+    const isArrowFunction = resolved.match.path.isArrowFunctionExpression();
+    if (!isFunctionDecl && !isArrowFunction) {
+        return primitiveFailure(source, "metadata-shape-unsupported", "generateMetadata must be a function", "export");
+    }
+    let returnArgument;
+    if (isFunctionDecl && node.body) {
+        const bodyStatements = resolved.match.path
+            .get("body")
+            .get("body");
+        if (bodyStatements.length !== 1 || !bodyStatements[0].isReturnStatement()) {
+            return primitiveFailure(source, "metadata-shape-unsupported", "generateMetadata must directly return an object literal", "export");
+        }
+        const argument = bodyStatements[0].get("argument");
+        if (!argument.node) {
+            return primitiveFailure(source, "metadata-shape-unsupported", "generateMetadata must directly return an object literal", "export");
+        }
+        returnArgument = argument;
+    }
+    else if (isArrowFunction) {
+        const body = node.body;
+        if (body.type === "BlockStatement") {
+            const bodyStatements = resolved.match.path.get("body");
+            const statements = bodyStatements.get("body");
+            if (statements.length !== 1 || !statements[0].isReturnStatement()) {
+                return primitiveFailure(source, "metadata-shape-unsupported", "generateMetadata must directly return an object literal", "export");
+            }
+            const argument = statements[0].get("argument");
+            if (!argument.node) {
+                return primitiveFailure(source, "metadata-shape-unsupported", "generateMetadata must directly return an object literal", "export");
+            }
+            returnArgument = argument;
+        }
+        else {
+            returnArgument = resolved.match.path.get("body");
+        }
+    }
+    else {
+        return primitiveFailure(source, "metadata-shape-unsupported", "generateMetadata must directly return an object literal", "export");
+    }
+    if (!returnArgument.node || !returnArgument.isObjectExpression()) {
+        return primitiveFailure(source, "metadata-shape-unsupported", "generateMetadata must directly return an object literal", "export");
+    }
+    const target = resolveMetadataObjectPath(returnArgument, path, source);
+    if (!target.ok) {
+        return target.result;
+    }
+    target.path.replaceWith(valueToExpression(next));
+    return printMutationWithOperation(parsed.ast, source, {
+        kind: "update-generate-metadata",
+        target: "export",
+        inverse: "restore-generate-metadata",
+    });
+}
+function resolveMetadataObjectPath(objectPath, segments, source) {
+    let current = objectPath;
+    for (const segment of segments) {
+        if (segment.kind !== "property" || !current.isObjectExpression()) {
+            return {
+                ok: false,
+                result: primitiveFailure(source, "metadata-shape-unsupported", "metadata path must stay within object properties", "export"),
+            };
+        }
+        if (current.node.properties.some((item) => item.type !== "ObjectProperty")) {
+            return {
+                ok: false,
+                result: primitiveFailure(source, "metadata-shape-unsupported", "metadata object cannot contain spread properties", "export"),
+            };
+        }
+        const property = current
+            .get("properties")
+            .find((item) => item.isObjectProperty() &&
+            (item.node.key.type === "Identifier"
+                ? item.node.key.name
+                : item.node.key.type === "StringLiteral"
+                    ? item.node.key.value
+                    : null) === segment.name);
+        if (!property || !property.isObjectProperty()) {
+            return {
+                ok: false,
+                result: primitiveFailure(source, "property-not-found", `Property '${segment.name}' not found`, "export"),
+            };
+        }
+        current = property.get("value");
+    }
+    return { ok: true, path: current };
+}
+function conflictingDirective(value) {
+    if (value === "use client") {
+        return "use server";
+    }
+    if (value === "use server") {
+        return "use client";
+    }
+    return null;
+}

package/dist/internal/ast/primitives/shared.d.ts

@@ -0,0 +1,60 @@
+import type * as t from "@babel/types";
+import type { AstDiagnostic, AstPrimitiveResult, JsxAttributeLocator, JsxNodeLocator, PrimitiveValue } from "../types.js";
+import { type InternalLocatorMatch } from "../locators/index.js";
+export interface OperationBuilderParams {
+    kind: string;
+    target: string;
+    inverse: string;
+}
+export declare function buildOperationDescription(beforeSource: string, afterSource: string, params: OperationBuilderParams): AstPrimitiveResult & {
+    ok: true;
+};
+export declare function printMutationWithOperation(ast: t.File, beforeSource: string, params: OperationBuilderParams): AstPrimitiveResult;
+export type ParsedMutationResult = {
+    ok: true;
+    ast: t.File;
+} | {
+    ok: false;
+    result: AstPrimitiveResult;
+};
+export declare function parseMutationSource(source: string, locatorKind?: InternalLocatorMatch["locatorKind"]): ParsedMutationResult;
+export declare function printMutation(ast: t.File, source: string): AstPrimitiveResult;
+export declare function resolveRequiredJsxNode(ast: t.File, locator: JsxNodeLocator, source: string): {
+    ok: true;
+    match: InternalLocatorMatch;
+} | {
+    ok: false;
+    result: AstPrimitiveResult;
+};
+export declare function resolveRequiredJsxElement(ast: t.File, locator: JsxNodeLocator, source: string): {
+    ok: true;
+    match: InternalLocatorMatch;
+} | {
+    ok: false;
+    result: AstPrimitiveResult;
+};
+export declare function resolveRequiredJsxAttribute(ast: t.File, locator: JsxAttributeLocator, source: string): {
+    ok: true;
+    match: InternalLocatorMatch;
+} | {
+    ok: false;
+    result: AstPrimitiveResult;
+};
+export declare function resolveOptionalJsxAttribute(ast: t.File, locator: JsxAttributeLocator): {
+    ok: true;
+    match: InternalLocatorMatch | null;
+} | {
+    ok: false;
+    diagnostic: AstDiagnostic;
+};
+export declare function valueToExpression(value: PrimitiveValue): t.Expression;
+export declare function valueToJsxAttributeValue(value: PrimitiveValue): t.StringLiteral | t.JSXExpressionContainer;
+export declare function createJsxAttribute(name: string, value: PrimitiveValue): t.JSXAttribute;
+export declare function parseJsxNodeSource(source: string, jsx: string): {
+    ok: true;
+    node: t.JSXElement | t.JSXFragment;
+} | {
+    ok: false;
+    result: AstPrimitiveResult;
+};
+export declare function objectPropertyKey(name: string): t.Identifier | t.StringLiteral;