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

package/dist/internal/provenance/capability-policy.d.ts

@@ -0,0 +1,15 @@
+export interface SourceRangeLike {
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+}
+export interface PolicyNodeLike {
+    sourceRange: SourceRangeLike;
+}
+export interface CapabilityPolicyResult {
+    allowed: boolean;
+    reason?: string;
+}
+export declare function evaluateInsertChildPolicy(source: string, node: PolicyNodeLike): CapabilityPolicyResult;
+export declare function evaluateCrossFileMovePolicy(source: string, node: PolicyNodeLike): CapabilityPolicyResult;

package/dist/internal/provenance/capability-policy.js

@@ -0,0 +1,96 @@
+import * as parser from "@babel/parser";
+import _traverse from "@babel/traverse";
+import * as t from "@babel/types";
+import { classifyExpressionDataSource, isApiSource, } from "./data-source-classifier.js";
+const traverse = (typeof _traverse === "function" ? _traverse : _traverse.default);
+export function evaluateInsertChildPolicy(source, node) {
+    const ast = parseSource(source);
+    if (!ast) {
+        return { allowed: true };
+    }
+    let blocked = false;
+    traverse(ast, {
+        CallExpression(path) {
+            if (!isNodeInsideRange(path.node, node.sourceRange) ||
+                !isMapCall(path.node)) {
+                return;
+            }
+            const calleePath = path.get("callee");
+            if (!calleePath.isMemberExpression()) {
+                return;
+            }
+            const objectPath = calleePath.get("object");
+            if (Array.isArray(objectPath) || !objectPath.isExpression()) {
+                return;
+            }
+            if (isApiSource(classifyExpressionDataSource(objectPath))) {
+                blocked = true;
+                path.stop();
+            }
+        },
+    });
+    return blocked
+        ? {
+            allowed: false,
+            reason: "Cannot add data-backed items to a dynamic API list",
+        }
+        : { allowed: true };
+}
+export function evaluateCrossFileMovePolicy(source, node) {
+    const ast = parseSource(source);
+    if (!ast) {
+        return { allowed: true };
+    }
+    let hasLocalDependency = false;
+    traverse(ast, {
+        JSXExpressionContainer(path) {
+            if (!isNodeInsideRange(path.node, node.sourceRange)) {
+                return;
+            }
+            if (!t.isJSXEmptyExpression(path.node.expression)) {
+                hasLocalDependency = true;
+                path.stop();
+            }
+        },
+    });
+    return hasLocalDependency
+        ? {
+            allowed: false,
+            reason: "Cannot move subtree across files because it depends on local binding expressions",
+        }
+        : { allowed: true };
+}
+function parseSource(source) {
+    try {
+        return parser.parse(source, {
+            sourceType: "module",
+            plugins: ["jsx", "typescript"],
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function isMapCall(call) {
+    const callee = call.callee;
+    return (t.isMemberExpression(callee) &&
+        t.isIdentifier(callee.property) &&
+        callee.property.name === "map");
+}
+function isNodeInsideRange(node, range) {
+    const loc = node.loc;
+    if (!loc) {
+        return false;
+    }
+    return (comparePosition({ line: loc.start.line, column: loc.start.column }, { line: range.startLine, column: range.startColumn }) >= 0 &&
+        comparePosition({ line: loc.end.line, column: loc.end.column }, { line: range.endLine, column: range.endColumn }) <= 0);
+}
+function comparePosition(left, right) {
+    if (left.line !== right.line) {
+        return left.line < right.line ? -1 : 1;
+    }
+    if (left.column !== right.column) {
+        return left.column < right.column ? -1 : 1;
+    }
+    return 0;
+}

package/dist/internal/provenance/data-source-classifier.d.ts

@@ -0,0 +1,14 @@
+import { type Binding, type NodePath } from "@babel/traverse";
+import * as t from "@babel/types";
+import type { ValuePathSegment } from "../ast/types.js";
+export type DataSourceKind = "static-source" | "prop-source" | "repeat-item-source" | "api-source" | "external-adapter-source" | "derived-readonly" | "unknown-unsupported";
+export interface DataSourceClassification {
+    kind: DataSourceKind;
+    readonly: boolean;
+    sourceId: string;
+    displayPath: string;
+    reason: string;
+}
+export declare function classifyExpressionDataSource(expressionPath: NodePath<t.Expression>, valuePath?: ValuePathSegment[]): DataSourceClassification | null;
+export declare function classifyBindingDataSource(binding: Binding, valuePath?: ValuePathSegment[]): DataSourceClassification | null;
+export declare function isApiSource(classification: DataSourceClassification | null): classification is DataSourceClassification;

package/dist/internal/provenance/data-source-classifier.js

@@ -0,0 +1,281 @@
+import _traverse from "@babel/traverse";
+import * as t from "@babel/types";
+const traverse = (typeof _traverse === "function" ? _traverse : _traverse.default);
+export function classifyExpressionDataSource(expressionPath, valuePath = []) {
+    if (expressionPath.isIdentifier()) {
+        const binding = expressionPath.scope.getBinding(expressionPath.node.name);
+        return binding ? classifyBindingDataSource(binding, valuePath) : null;
+    }
+    if (expressionPath.isMemberExpression()) {
+        const root = getMemberExpressionRoot(expressionPath.node);
+        if (!root) {
+            return null;
+        }
+        const binding = expressionPath.scope.getBinding(root);
+        return binding ? classifyBindingDataSource(binding, valuePath) : null;
+    }
+    if (expressionPath.isAwaitExpression() ||
+        isFetchLikeExpression(expressionPath.node)) {
+        return apiSource(getExpressionSourceId(expressionPath.node), valuePath, "awaited or fetched expression");
+    }
+    return null;
+}
+export function classifyBindingDataSource(binding, valuePath = []) {
+    const queryHook = classifyQueryHookDataBinding(binding, valuePath);
+    if (queryHook) {
+        return queryHook;
+    }
+    const hookState = classifyHookStateBinding(binding, valuePath);
+    if (hookState) {
+        return hookState;
+    }
+    const asyncResult = classifyAsyncResultBinding(binding, valuePath);
+    if (asyncResult) {
+        return asyncResult;
+    }
+    return null;
+}
+export function isApiSource(classification) {
+    return classification?.kind === "api-source";
+}
+function classifyQueryHookDataBinding(binding, valuePath) {
+    if (binding.path.isVariableDeclarator() &&
+        t.isObjectPattern(binding.path.node.id)) {
+        const prop = binding.path.node.id.properties.find((property) => t.isObjectProperty(property) &&
+            getObjectPropertyKey(property) === "data" &&
+            patternContainsBinding(property.value, binding.identifier.name));
+        const initPath = binding.path.get("init");
+        if (prop &&
+            initPath?.isCallExpression() &&
+            isQueryHookCall(initPath.node)) {
+            return apiSource(binding.identifier.name, valuePath, "query hook data binding");
+        }
+    }
+    const propertyPath = findObjectPropertyForBinding(binding);
+    if (!propertyPath) {
+        return null;
+    }
+    const propertyName = getObjectPropertyKey(propertyPath.node);
+    if (propertyName !== "data") {
+        return null;
+    }
+    const declaratorPath = propertyPath.findParent((parent) => parent.isVariableDeclarator());
+    if (!declaratorPath?.isVariableDeclarator()) {
+        return null;
+    }
+    const initPath = declaratorPath.get("init");
+    if (!initPath?.isCallExpression() || !isQueryHookCall(initPath.node)) {
+        return null;
+    }
+    return apiSource(binding.identifier.name, valuePath, "query hook data binding");
+}
+function classifyHookStateBinding(binding, valuePath) {
+    if (binding.path.isVariableDeclarator() &&
+        t.isArrayPattern(binding.path.node.id)) {
+        const initPath = binding.path.get("init");
+        if (!initPath?.isCallExpression() || !isUseStateCall(initPath.node)) {
+            return null;
+        }
+        const [state, setter] = binding.path.node.id.elements;
+        if (!t.isIdentifier(state) ||
+            state.name !== binding.identifier.name ||
+            !t.isIdentifier(setter)) {
+            return null;
+        }
+        return scopeWritesSetterFromApi(binding, setter.name)
+            ? apiSource(binding.identifier.name, valuePath, "state setter is updated by API data")
+            : null;
+    }
+    if (!binding.path.isIdentifier()) {
+        return null;
+    }
+    const arrayPattern = binding.path.parentPath;
+    if (!arrayPattern?.isArrayPattern()) {
+        return null;
+    }
+    const declaratorPath = arrayPattern.parentPath;
+    if (!declaratorPath?.isVariableDeclarator()) {
+        return null;
+    }
+    const initPath = declaratorPath.get("init");
+    if (!initPath?.isCallExpression() || !isUseStateCall(initPath.node)) {
+        return null;
+    }
+    const stateIndex = arrayPattern.node.elements.findIndex((element) => element === binding.path.node);
+    if (stateIndex !== 0) {
+        return null;
+    }
+    const setter = arrayPattern.node.elements[1];
+    if (!t.isIdentifier(setter)) {
+        return null;
+    }
+    return scopeWritesSetterFromApi(binding, setter.name)
+        ? apiSource(binding.identifier.name, valuePath, "state setter is updated by API data")
+        : null;
+}
+function classifyAsyncResultBinding(binding, valuePath) {
+    const declaratorPath = binding.path.isVariableDeclarator()
+        ? binding.path
+        : binding.path.findParent((parent) => parent.isVariableDeclarator());
+    if (!declaratorPath?.isVariableDeclarator()) {
+        return null;
+    }
+    const initPath = declaratorPath.get("init");
+    if (!initPath?.isExpression()) {
+        return null;
+    }
+    if (initPath.isAwaitExpression()) {
+        return apiSource(binding.identifier.name, valuePath, "awaited binding result");
+    }
+    if (isFetchLikeExpression(initPath.node)) {
+        return apiSource(binding.identifier.name, valuePath, "fetch-backed binding result");
+    }
+    return null;
+}
+function findObjectPropertyForBinding(binding) {
+    if (!binding.path.isIdentifier()) {
+        return null;
+    }
+    const parent = binding.path.parentPath;
+    if (parent?.isObjectProperty()) {
+        return parent;
+    }
+    if (parent?.isAssignmentPattern() && parent.parentPath?.isObjectProperty()) {
+        return parent.parentPath;
+    }
+    return null;
+}
+function patternContainsBinding(pattern, bindingName) {
+    if (t.isIdentifier(pattern)) {
+        return pattern.name === bindingName;
+    }
+    if (t.isAssignmentPattern(pattern)) {
+        return patternContainsBinding(pattern.left, bindingName);
+    }
+    if (t.isObjectPattern(pattern)) {
+        return pattern.properties.some((property) => t.isObjectProperty(property)
+            ? patternContainsBinding(property.value, bindingName)
+            : patternContainsBinding(property.argument, bindingName));
+    }
+    if (t.isArrayPattern(pattern)) {
+        return pattern.elements.some((element) => !!element &&
+            patternContainsBinding((t.isRestElement(element)
+                ? element.argument
+                : element), bindingName));
+    }
+    return false;
+}
+function scopeWritesSetterFromApi(binding, setterName) {
+    let hasFetch = false;
+    let writesSetter = false;
+    const scopeRoot = binding.scope.path;
+    scopeRoot.traverse({
+        CallExpression(path) {
+            if (isFetchLikeExpression(path.node)) {
+                hasFetch = true;
+            }
+            if (usesIdentifier(path.node.callee, setterName) ||
+                path.node.arguments.some((argument) => t.isIdentifier(argument) && argument.name === setterName)) {
+                writesSetter = true;
+            }
+        },
+    });
+    return hasFetch && writesSetter;
+}
+function isQueryHookCall(call) {
+    const calleeName = getCalleeName(call.callee);
+    return (calleeName === "useQuery" ||
+        calleeName === "useSWR" ||
+        calleeName === "useSuspenseQuery");
+}
+function isUseStateCall(call) {
+    return getCalleeName(call.callee) === "useState";
+}
+function isFetchLikeExpression(expression) {
+    return visitNode(expression, (node) => {
+        return t.isCallExpression(node) && getCalleeName(node.callee) === "fetch";
+    });
+}
+function getMemberExpressionRoot(expression) {
+    let current = expression;
+    while (t.isMemberExpression(current)) {
+        current = current.object;
+    }
+    return t.isIdentifier(current) ? current.name : null;
+}
+function getObjectPropertyKey(property) {
+    if (property.computed) {
+        return null;
+    }
+    if (t.isIdentifier(property.key)) {
+        return property.key.name;
+    }
+    if (t.isStringLiteral(property.key)) {
+        return property.key.value;
+    }
+    return null;
+}
+function getCalleeName(callee) {
+    if (t.isIdentifier(callee)) {
+        return callee.name;
+    }
+    if (t.isMemberExpression(callee) && t.isIdentifier(callee.property)) {
+        return callee.property.name;
+    }
+    return null;
+}
+function usesIdentifier(node, name) {
+    return visitNode(node, (candidate) => {
+        return t.isIdentifier(candidate) && candidate.name === name;
+    });
+}
+function visitNode(node, predicate) {
+    if (predicate(node)) {
+        return true;
+    }
+    const keys = t.VISITOR_KEYS[node.type];
+    if (!keys) {
+        return false;
+    }
+    for (const key of keys) {
+        const value = node[key];
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (t.isNode(item) && visitNode(item, predicate)) {
+                    return true;
+                }
+            }
+            continue;
+        }
+        if (t.isNode(value) && visitNode(value, predicate)) {
+            return true;
+        }
+    }
+    return false;
+}
+function getExpressionSourceId(expression) {
+    if (t.isIdentifier(expression)) {
+        return expression.name;
+    }
+    if (t.isCallExpression(expression)) {
+        return getCalleeName(expression.callee) ?? "api";
+    }
+    if (t.isAwaitExpression(expression)) {
+        return "awaited-api";
+    }
+    return "api";
+}
+function apiSource(sourceId, valuePath, reason) {
+    return {
+        kind: "api-source",
+        readonly: true,
+        sourceId,
+        displayPath: appendValuePath(sourceId, valuePath),
+        reason,
+    };
+}
+function appendValuePath(base, path) {
+    return path.reduce((expression, segment) => segment.kind === "property"
+        ? `${expression}.${segment.name}`
+        : `${expression}[${segment.index}]`, base);
+}

package/dist/internal/provenance/resolve-text-provenance.d.ts

@@ -0,0 +1,45 @@
+import * as t from "@babel/types";
+import type { ConditionalSourceCandidate, RenderSourceGraph, TextSegment } from "../graph/types.js";
+import type { ExternalAdapterRegistration, ExternalSourceResolver, FunctionCallContract, ProvenanceResolution, ResolvedTextWriteTarget } from "./types.js";
+interface ResolveParams {
+    file: string;
+    source: string;
+    segment: TextSegment;
+    readFile: (file: string) => Promise<string>;
+    exists: (file: string) => Promise<boolean>;
+    graph?: RenderSourceGraph;
+    externalSourceResolvers?: ExternalSourceResolver[];
+    externalAdapters?: ExternalAdapterRegistration[];
+    functionCallContracts?: FunctionCallContract[];
+    fileCache?: ProvenanceFileCache;
+}
+interface ResolveBaseParams {
+    file: string;
+    source: string;
+    readFile: (file: string) => Promise<string>;
+    exists: (file: string) => Promise<boolean>;
+    graph?: RenderSourceGraph;
+    externalSourceResolvers?: ExternalSourceResolver[];
+    externalAdapters?: ExternalAdapterRegistration[];
+    functionCallContracts?: FunctionCallContract[];
+    fileCache?: ProvenanceFileCache;
+}
+export type ResolveProvenanceParams = (ResolveBaseParams & {
+    target: {
+        kind: "text-segment";
+        segment: TextSegment;
+    };
+}) | (ResolveBaseParams & {
+    target: {
+        kind: "conditional-branch";
+        candidate: ConditionalSourceCandidate;
+    };
+});
+interface LoadedFile {
+    source: string;
+    ast: t.File | null;
+}
+export type ProvenanceFileCache = Map<string, LoadedFile>;
+export declare function resolveTextProvenance(params: ResolveParams): Promise<ResolvedTextWriteTarget | null>;
+export declare function resolveProvenance(params: ResolveProvenanceParams): Promise<ProvenanceResolution>;
+export {};