@dcoder-x/plugin-shared 0.1.3 → 0.1.4

package/dist/extractors/InteractionGraphExtractor.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractionGraphExtractor = void 0;
+const ComponentContextResolver_1 = require("./ComponentContextResolver");
+/**
+ * Extracts interaction graphs from React component ASTs.
+ * Maps event handlers -> state mutations -> conditional renders and effects.
+ */
+class InteractionGraphExtractor {
+    constructor() {
+        this.contextResolver = new ComponentContextResolver_1.ComponentContextResolver();
+    }
+    /**
+     * Extract all interactions (trigger -> effect mappings) from a component.
+     */
+    extractInteractions(componentPath, componentName) {
+        const context = this.contextResolver.extractContext(componentPath, componentName);
+        const interactions = [];
+        // Walk all JSX elements looking for event handlers
+        componentPath.traverse({
+            JSXOpeningElement: (jsxPath) => {
+                const attributes = jsxPath.node.attributes || [];
+                for (const attr of attributes) {
+                    if (attr.type === 'JSXAttribute' &&
+                        attr.name?.name &&
+                        attr.name.name.startsWith('on')) {
+                        const eventName = attr.name.name;
+                        const settersCalledByEvent = this.resolveStateSettersForAttribute(attr, context);
+                        if (settersCalledByEvent.length === 0)
+                            continue;
+                        const interaction = this.extractTriggerAndEffect(jsxPath, componentPath, eventName, context, settersCalledByEvent);
+                        if (interaction) {
+                            interactions.push(interaction);
+                        }
+                    }
+                }
+            },
+        });
+        return interactions;
+    }
+    /**
+     * Extract trigger/effect pair from a JSX element with an event handler.
+     */
+    extractTriggerAndEffect(jsxPath, componentPath, eventName, context, settersCalledByEvent) {
+        const tagName = jsxPath.node.name?.name || 'unknown';
+        const stateVar = settersCalledByEvent[0]; // Take first setter as primary
+        const trigger = {
+            event: eventName,
+            element: tagName,
+            setsState: stateVar,
+        };
+        // Look for conditional effects that depend on the modified state
+        const effect = this.findConditionalEffect(jsxPath, componentPath, stateVar);
+        if (!effect) {
+            return null;
+        }
+        return { trigger, effect };
+    }
+    resolveStateSettersForAttribute(attr, context) {
+        if (attr.type !== 'JSXAttribute' || !attr.value || attr.value.type !== 'JSXExpressionContainer') {
+            return [];
+        }
+        const expression = attr.value.expression;
+        if (!expression)
+            return [];
+        const setterMap = new Map();
+        for (const stateVar of context.stateVariables) {
+            if (stateVar.setter) {
+                setterMap.set(stateVar.setter, stateVar.name);
+            }
+        }
+        if (expression.type === 'Identifier') {
+            const handler = context.eventHandlers.find((h) => h.name === expression.name);
+            return handler?.callsStateSetters ?? [];
+        }
+        if (expression.type === 'ArrowFunctionExpression' || expression.type === 'FunctionExpression') {
+            const result = new Set();
+            this.collectSettersFromNode(expression.body, setterMap, result);
+            return Array.from(result);
+        }
+        return [];
+    }
+    collectSettersFromNode(node, setterMap, result) {
+        if (!node || typeof node !== 'object')
+            return;
+        if (node.type === 'CallExpression') {
+            const callee = node.callee;
+            if (callee?.type === 'Identifier') {
+                const stateName = setterMap.get(callee.name);
+                if (stateName)
+                    result.add(stateName);
+            }
+            else if (callee?.type === 'MemberExpression' && callee.property?.type === 'Identifier') {
+                const stateName = setterMap.get(callee.property.name);
+                if (stateName)
+                    result.add(stateName);
+            }
+        }
+        for (const key of Object.keys(node)) {
+            const value = node[key];
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    this.collectSettersFromNode(child, setterMap, result);
+                }
+            }
+            else if (value && typeof value === 'object') {
+                this.collectSettersFromNode(value, setterMap, result);
+            }
+        }
+    }
+    /**
+     * Find conditional renders/effects that depend on a state variable.
+     * Looks for logical expressions and ternaries using the state var.
+     */
+    findConditionalEffect(jsxPath, componentPath, stateVar) {
+        const directEffect = this.findConditionalEffectInAncestors(jsxPath, stateVar);
+        if (directEffect) {
+            return directEffect;
+        }
+        return this.findConditionalEffectInComponent(componentPath, stateVar);
+    }
+    findConditionalEffectInAncestors(jsxPath, stateVar) {
+        let effectFound = null;
+        let current = jsxPath.parentPath;
+        while (current && !effectFound) {
+            const node = current.node;
+            // Check for logical AND/OR: condition && <Component />
+            if (node.type === 'LogicalExpression') {
+                if (this.nodeReferencesState(node.left, stateVar)) {
+                    const rendersWhenTrue = this.extractComponentNameFromNode(node.right);
+                    if (rendersWhenTrue) {
+                        effectFound = {
+                            type: 'conditionalRender',
+                            rendersWhenTrue,
+                            waitStrategy: 'elementAppears',
+                            selector: `[data-clippy-component='${rendersWhenTrue}']`,
+                        };
+                    }
+                }
+            }
+            // Check for ternary: condition ? <Component /> : null
+            if (node.type === 'ConditionalExpression') {
+                if (this.nodeReferencesState(node.test, stateVar)) {
+                    const rendersWhenTrue = this.extractComponentNameFromNode(node.consequent);
+                    const rendersWhenFalse = this.extractComponentNameFromNode(node.alternate);
+                    if (rendersWhenTrue || rendersWhenFalse) {
+                        effectFound = {
+                            type: 'conditionalRender',
+                            rendersWhenTrue: rendersWhenTrue ?? undefined,
+                            rendersWhenFalse: rendersWhenFalse ?? undefined,
+                            waitStrategy: 'elementAppears',
+                            selector: rendersWhenTrue ? `[data-clippy-component='${rendersWhenTrue}']` : undefined,
+                        };
+                    }
+                }
+            }
+            current = current.parentPath;
+        }
+        return effectFound;
+    }
+    findConditionalEffectInComponent(componentPath, stateVar) {
+        let effectFound = null;
+        componentPath.traverse({
+            LogicalExpression: (path) => {
+                if (effectFound)
+                    return;
+                const node = path.node;
+                if (this.nodeReferencesState(node.left, stateVar)) {
+                    const rendersWhenTrue = this.extractComponentNameFromNode(node.right);
+                    if (rendersWhenTrue) {
+                        effectFound = {
+                            type: 'conditionalRender',
+                            rendersWhenTrue,
+                            waitStrategy: 'elementAppears',
+                            selector: `[data-clippy-component='${rendersWhenTrue}']`,
+                        };
+                    }
+                }
+            },
+            ConditionalExpression: (path) => {
+                if (effectFound)
+                    return;
+                const node = path.node;
+                if (this.nodeReferencesState(node.test, stateVar)) {
+                    const rendersWhenTrue = this.extractComponentNameFromNode(node.consequent);
+                    const rendersWhenFalse = this.extractComponentNameFromNode(node.alternate);
+                    if (rendersWhenTrue || rendersWhenFalse) {
+                        effectFound = {
+                            type: 'conditionalRender',
+                            rendersWhenTrue: rendersWhenTrue ?? undefined,
+                            rendersWhenFalse: rendersWhenFalse ?? undefined,
+                            waitStrategy: 'elementAppears',
+                            selector: rendersWhenTrue ? `[data-clippy-component='${rendersWhenTrue}']` : undefined,
+                        };
+                    }
+                }
+            },
+        });
+        return effectFound;
+    }
+    /**
+     * Check if a node references a specific state variable by name.
+     */
+    nodeReferencesState(node, stateVar) {
+        if (node.type === 'Identifier' && node.name === stateVar) {
+            return true;
+        }
+        if (node.type === 'MemberExpression') {
+            return this.nodeReferencesState(node.object, stateVar);
+        }
+        if (node.type === 'CallExpression') {
+            return this.nodeReferencesState(node.callee, stateVar);
+        }
+        if (node.type === 'BinaryExpression' || node.type === 'LogicalExpression') {
+            return this.nodeReferencesState(node.left, stateVar) || this.nodeReferencesState(node.right, stateVar);
+        }
+        if (node.type === 'UnaryExpression') {
+            return this.nodeReferencesState(node.argument, stateVar);
+        }
+        return false;
+    }
+    /**
+     * Extract component name from a JSX element or identifier.
+     */
+    extractComponentNameFromNode(node) {
+        if (!node)
+            return null;
+        if (node.type === 'JSXElement' && node.openingElement?.name?.name) {
+            const name = node.openingElement.name.name;
+            // Only return if it looks like a component (PascalCase)
+            return /^[A-Z]/.test(name) ? name : null;
+        }
+        if (node.type === 'JSXFragment') {
+            return null;
+        }
+        if (node.type === 'Identifier' && /^[A-Z]/.test(node.name)) {
+            return node.name;
+        }
+        if (node.type === 'MemberExpression' && node.property?.name) {
+            return node.property.name;
+        }
+        return null;
+    }
+}
+exports.InteractionGraphExtractor = InteractionGraphExtractor;

package/dist/extractors/SelectorGenerator.d.ts

@@ -1,5 +1,10 @@
 import type { DiscoveredElement, ElementWithSelectors } from '../types';
 export declare class SelectorGenerator {
-    generate(elements: DiscoveredElement[]): ElementWithSelectors[];
+    generate(elements: DiscoveredElement[], injectedMap?: Record<string, Array<{
+        clippyId: string;
+        component: string;
+        tag: string;
+        line: number;
+    }>>): ElementWithSelectors[];
     private generateForElement;
 }

package/dist/extractors/SelectorGenerator.js

@@ -2,15 +2,40 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SelectorGenerator = void 0;
 class SelectorGenerator {
-    generate(elements) {
+    generate(elements, injectedMap) {
         return elements.map((el) => ({
             ...el,
-            selectors: this.generateForElement(el),
+            selectors: this.generateForElement(el, injectedMap),
         }));
     }
-    generateForElement(el) {
+    generateForElement(el, injectedMap) {
         const candidates = [];
         const p = el.staticProps;
+        // Prefer injected clippy ids when available for the element's file
+        try {
+            if (injectedMap && el.filePath) {
+                const entries = injectedMap[el.filePath];
+                if (entries && entries.length) {
+                    // Prefer exact line match when available
+                    let match = null;
+                    if (el.loc && el.loc.line) {
+                        match = entries.find((e) => e.line === el.loc.line);
+                    }
+                    // Fallback to tag/component match
+                    if (!match) {
+                        match = entries.find((e) => e.tag === el.tag);
+                    }
+                    if (match) {
+                        candidates.push({
+                            type: 'clippy_id',
+                            value: `[data-clippy-id="${match.clippyId}"]`,
+                            confidence: 0.999,
+                        });
+                    }
+                }
+            }
+        }
+        catch { }
         if (p['data-testid']) {
             candidates.push({
                 type: 'testid',

package/dist/index.d.ts

@@ -1 +1,6 @@
-export type { ClippyPluginOptions, ModuleGraphSource, RollupModuleInfo, DiscoveredRoute, DiscoveredElement, SelectorCandidate, ElementWithSelectors, FlowEdge, InferredFlow, KnowledgePackage, } from './types';
+export * from './types';
+export * from './injection/ClippyIdInjector';
+export * from './buildId';
+export * from './upload/Adapter';
+export * from './upload/BackendAdapter';
+export * from './upload/BackendUploadAdapter';

package/dist/index.js

@@ -1,2 +1,22 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./injection/ClippyIdInjector"), exports);
+__exportStar(require("./buildId"), exports);
+__exportStar(require("./upload/Adapter"), exports);
+__exportStar(require("./upload/BackendAdapter"), exports);
+__exportStar(require("./upload/BackendUploadAdapter"), exports);

package/dist/injection/ClippyIdInjector.d.ts

@@ -0,0 +1,12 @@
+export interface InjectedEntry {
+    clippyId: string;
+    component: string;
+    tag: string;
+    line: number;
+}
+export interface InjectResult {
+    source: string;
+    injectedCount: number;
+    injected: InjectedEntry[];
+}
+export declare function injectClippyIds(source: string, filePath: string): InjectResult;

package/dist/injection/ClippyIdInjector.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectClippyIds = injectClippyIds;
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const HtmlTagGuards_1 = require("./HtmlTagGuards");
+const IdStrategy_1 = require("./IdStrategy");
+function injectClippyIds(source, filePath) {
+    let ast;
+    try {
+        ast = (0, parser_1.parse)(source, {
+            sourceType: 'module',
+            plugins: ['typescript', 'jsx'],
+            ranges: true,
+        });
+    }
+    catch {
+        return { source, injectedCount: 0, injected: [] };
+    }
+    const edits = [];
+    const injected = [];
+    (0, traverse_1.default)(ast, {
+        JSXOpeningElement(path) {
+            const opening = path.node;
+            const tagName = (0, HtmlTagGuards_1.getJSXTagName)(opening.name);
+            if (!tagName || !(0, HtmlTagGuards_1.isIntrinsicTag)(tagName))
+                return;
+            const attrs = opening.attributes;
+            if ((0, HtmlTagGuards_1.hasAttribute)(attrs, 'data-clippy-id'))
+                return;
+            const componentName = findEnclosingComponentName(path) || (0, IdStrategy_1.deriveComponentName)(filePath);
+            const line = opening.loc?.start.line ?? 0;
+            const clippyId = (0, IdStrategy_1.deriveClippyId)(componentName, tagName, line);
+            const componentAttr = (0, HtmlTagGuards_1.hasAttribute)(attrs, 'data-clippy-component')
+                ? ''
+                : ` data-clippy-component="${componentName}"`;
+            const insertText = ` data-clippy-id="${clippyId}"${componentAttr}`;
+            const insertIndex = findAttributeInsertIndex(source, opening.range);
+            if (insertIndex === null)
+                return;
+            edits.push({ index: insertIndex, text: insertText });
+            injected.push({ clippyId, component: componentName, tag: tagName, line });
+        },
+    });
+    if (edits.length === 0) {
+        return { source, injectedCount: 0, injected: [] };
+    }
+    const transformed = applyEdits(source, edits);
+    return { source: transformed, injectedCount: edits.length, injected };
+}
+function findEnclosingComponentName(path) {
+    let current = path;
+    while (current) {
+        if (current.isFunctionDeclaration() && current.node.id?.name) {
+            return current.node.id.name;
+        }
+        if (current.isClassDeclaration() && current.node.id?.name) {
+            return current.node.id.name;
+        }
+        if (current.isVariableDeclarator() && current.node.id?.type === 'Identifier') {
+            return current.node.id.name;
+        }
+        if ((current.isArrowFunctionExpression() || current.isFunctionExpression()) &&
+            current.parentPath?.isVariableDeclarator() &&
+            current.parentPath.node.id?.type === 'Identifier') {
+            return current.parentPath.node.id.name;
+        }
+        current = current.parentPath;
+    }
+    return null;
+}
+function findAttributeInsertIndex(source, range) {
+    if (!range)
+        return null;
+    const end = range[1];
+    const closeCharIndex = source.lastIndexOf('>', end - 1);
+    if (closeCharIndex === -1)
+        return null;
+    return closeCharIndex;
+}
+function applyEdits(source, edits) {
+    const sorted = edits.slice().sort((a, b) => b.index - a.index);
+    let result = source;
+    for (const edit of sorted) {
+        result = result.slice(0, edit.index) + edit.text + result.slice(edit.index);
+    }
+    return result;
+}

package/dist/injection/HtmlTagGuards.d.ts

@@ -0,0 +1,3 @@
+export declare function isIntrinsicTag(tagName: string): boolean;
+export declare function getJSXTagName(name: any): string | null;
+export declare function hasAttribute(attributes: any[], name: string): boolean;

package/dist/injection/HtmlTagGuards.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIntrinsicTag = isIntrinsicTag;
+exports.getJSXTagName = getJSXTagName;
+exports.hasAttribute = hasAttribute;
+const HTML_TAGS = new Set([
+    'a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo',
+    'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup',
+    'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed',
+    'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+    'head', 'header', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'keygen',
+    'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'menu', 'menuitem', 'meta', 'meter',
+    'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture',
+    'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select',
+    'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody',
+    'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track',
+    'u', 'ul', 'var', 'video', 'wbr',
+]);
+function isIntrinsicTag(tagName) {
+    return HTML_TAGS.has(tagName);
+}
+function getJSXTagName(name) {
+    if (!name)
+        return null;
+    if (name.type === 'JSXIdentifier') {
+        return name.name;
+    }
+    if (name.type === 'JSXMemberExpression') {
+        return null;
+    }
+    if (name.type === 'JSXNamespacedName') {
+        return null;
+    }
+    return null;
+}
+function hasAttribute(attributes, name) {
+    return attributes.some((attr) => attr.type === 'JSXAttribute' &&
+        attr.name &&
+        attr.name.type === 'JSXIdentifier' &&
+        attr.name.name === name);
+}

package/dist/injection/IdStrategy.d.ts

@@ -0,0 +1,2 @@
+export declare function deriveComponentName(filePath: string, fallback?: string): string;
+export declare function deriveClippyId(componentName: string, tagName: string, lineNumber: number): string;

package/dist/injection/IdStrategy.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveComponentName = deriveComponentName;
+exports.deriveClippyId = deriveClippyId;
+const path_1 = __importDefault(require("path"));
+function deriveComponentName(filePath, fallback) {
+    if (fallback)
+        return fallback;
+    const base = path_1.default.basename(filePath, path_1.default.extname(filePath));
+    if (!base || base === 'index') {
+        return 'UnknownComponent';
+    }
+    return normalizeComponentName(base);
+}
+function deriveClippyId(componentName, tagName, lineNumber) {
+    const sanitizedComponent = normalizeComponentName(componentName);
+    const normalizedTag = tagName.replace(/[^a-z0-9]/gi, '') || 'element';
+    const stableLine = lineNumber > 0 ? lineNumber : 0;
+    return `${sanitizedComponent}-${normalizedTag}-${stableLine}`;
+}
+function normalizeComponentName(value) {
+    const sanitized = value
+        .replace(/[^A-Za-z0-9]+/g, ' ')
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((segment) => segment
+        .replace(/[^A-Za-z0-9]/g, '')
+        .replace(/^[^A-Za-z]+/, '')
+        .replace(/([a-z])([A-Z])/g, '$1$2'))
+        .filter(Boolean)
+        .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
+        .join('');
+    return sanitized || 'Component';
+}

package/dist/types.d.ts

@@ -4,6 +4,11 @@ export interface ClippyPluginOptions {
     skipUpload?: boolean;
     productionOnly?: boolean;
     localOutputDir?: string;
+    artifactUploadMode?: 'single' | 'split';
+    legacyPackageMode?: boolean;
+    uploadAdapter?: {
+        uploadArtifacts?: (artifacts: PolicyArtifacts) => Promise<UploadResult>;
+    };
 }
 export type ModuleGraphSource = {
     type: 'webpack';
@@ -33,9 +38,12 @@ export interface DiscoveredElement {
     nearbyText: string[];
     semanticRole: string;
     interactions: string[];
+    loc?: {
+        line: number;
+    };
 }
 export interface SelectorCandidate {
-    type: 'testid' | 'aria' | 'id' | 'semantic' | 'text' | 'structural';
+    type: 'clippy_id' | 'testid' | 'aria' | 'id' | 'semantic' | 'text' | 'structural';
     value: string;
     confidence: number;
 }
@@ -51,9 +59,102 @@ export interface FlowEdge {
 export interface InferredFlow {
     id: string;
     name: string;
+    page: string;
     steps: string[];
     edges: FlowEdge[];
 }
+export interface ArtifactMetadata {
+    version: string;
+    buildId: string;
+    generatedAt: string;
+    bundler: 'webpack' | 'vite';
+}
+export interface TriggerSpec {
+    event: string;
+    element: string;
+    setsState?: string;
+}
+export interface EffectSpec {
+    type: 'conditionalRender' | 'asyncEffect' | 'contextDependency';
+    rendersWhenTrue?: string;
+    rendersWhenFalse?: string;
+    waitStrategy: 'elementAppears' | 'domSettle' | 'none';
+    selector?: string;
+    settleMs?: number;
+}
+export interface ComponentInteraction {
+    trigger: TriggerSpec;
+    effect: EffectSpec;
+}
+export interface PolicySelectorEntry {
+    clippyId: string;
+    selector: string;
+    tag: string;
+    component: string;
+    route: string;
+    filePath: string;
+    attributes: Array<{
+        name: string;
+        value: string;
+    }>;
+    candidates: SelectorCandidate[];
+}
+export interface PolicyFlowStep {
+    step: number;
+    action: string;
+    target: string;
+    triggers?: Array<{
+        renders: string;
+        waitStrategy: 'elementAppears' | 'domSettle' | 'none';
+    }>;
+}
+export interface PolicyFlow {
+    flowId: string;
+    page: string;
+    intentPatterns: string[];
+    steps: PolicyFlowStep[];
+}
+export interface PolicyComponent {
+    name: string;
+    filePath: string;
+    route: string;
+    stateVariables: Array<{
+        name: string;
+        setter?: string;
+        initialValue?: string;
+    }>;
+    interactions: ComponentInteraction[];
+}
+export interface PolicyDocument extends ArtifactMetadata {
+    routes: DiscoveredRoute[];
+    selectors: PolicySelectorEntry[];
+    components: PolicyComponent[];
+    flows: PolicyFlow[];
+}
+export interface SelectorManifestEntry {
+    id: string;
+    selector: string;
+    component: string;
+    tag: string;
+    route: string;
+}
+export interface SelectorManifest {
+    version: string;
+    buildId: string;
+    generatedAt: string;
+    selectors: SelectorManifestEntry[];
+}
+export interface PolicyArtifacts {
+    metadata: ArtifactMetadata;
+    policy: PolicyDocument;
+    selectorManifest: SelectorManifest;
+}
+export interface UploadResult {
+    skipped: boolean;
+    policyUploaded: boolean;
+    selectorsUploaded: boolean;
+    mode: 'single' | 'split';
+}
 export interface KnowledgePackage {
     buildId: string;
     generatedAt: string;

package/dist/upload/Adapter.d.ts

@@ -0,0 +1,3 @@
+import type { ClippyPluginOptions, PolicyArtifacts, UploadResult } from '../types';
+export declare function performUpload(artifacts: PolicyArtifacts, options: ClippyPluginOptions): Promise<UploadResult>;
+export default performUpload;

package/dist/upload/Adapter.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performUpload = performUpload;
+const Uploader_1 = require("./Uploader");
+async function performUpload(artifacts, options) {
+    // Allow adapters to supply a custom upload implementation
+    if (options && options.uploadAdapter && typeof options.uploadAdapter.uploadArtifacts === 'function') {
+        return options.uploadAdapter.uploadArtifacts(artifacts);
+    }
+    const uploader = new Uploader_1.Uploader(options);
+    return uploader.uploadArtifacts(artifacts);
+}
+exports.default = performUpload;