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

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

@@ -1,96 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,281 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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 {};