opendevbrowser 0.0.16 → 0.0.18

package/extension/dist/canvas/model.js

@@ -0,0 +1,341 @@
+const CODE_SYNC_STATES = new Set([
+    "idle",
+    "session_join_pending",
+    "pull_pending",
+    "push_pending",
+    "in_sync",
+    "drift_detected",
+    "conflict",
+    "unsupported",
+    "lease_lost",
+    "projection_fallback"
+]);
+const CODE_SYNC_DRIFT_STATES = new Set([
+    "clean",
+    "source_changed",
+    "document_changed",
+    "conflict"
+]);
+const CODE_SYNC_WATCH_STATES = new Set(["idle", "watching", "stopped"]);
+const CODE_SYNC_PROJECTIONS = new Set(["canvas_html", "bound_app_runtime"]);
+const CODE_SYNC_FALLBACK_REASONS = new Set([
+    "runtime_bridge_unavailable",
+    "runtime_projection_unsupported",
+    "runtime_projection_failed",
+    "runtime_instrumentation_missing",
+    "fallback_canvas_html"
+]);
+const ATTACHED_CLIENT_ROLES = new Set(["lease_holder", "observer"]);
+export function normalizeCanvasSessionSummary(value) {
+    const summary = isRecord(value) ? { ...value } : {};
+    return {
+        ...summary,
+        canvasSessionId: optionalString(summary.canvasSessionId) ?? undefined,
+        mode: optionalString(summary.mode) ?? undefined,
+        planStatus: optionalString(summary.planStatus) ?? undefined,
+        preflightState: optionalString(summary.preflightState) ?? undefined,
+        libraryPolicy: isRecord(summary.libraryPolicy) ? summary.libraryPolicy : undefined,
+        componentInventoryCount: optionalNumber(summary.componentInventoryCount) ?? undefined,
+        availableInventoryCount: optionalNumber(summary.availableInventoryCount) ?? undefined,
+        catalogKitIds: readStringArray(summary.catalogKitIds),
+        availableStarterCount: optionalNumber(summary.availableStarterCount) ?? undefined,
+        componentSourceKinds: readStringArray(summary.componentSourceKinds),
+        frameworkIds: readStringArray(summary.frameworkIds),
+        pluginIds: readStringArray(summary.pluginIds),
+        inventoryOrigins: readStringArray(summary.inventoryOrigins),
+        declaredCapabilities: readStringArray(summary.declaredCapabilities),
+        grantedCapabilities: readStringArray(summary.grantedCapabilities),
+        capabilityDenials: Array.isArray(summary.capabilityDenials)
+            ? summary.capabilityDenials.flatMap((entry) => normalizeCapabilityGrant(entry))
+            : [],
+        pluginErrors: Array.isArray(summary.pluginErrors)
+            ? summary.pluginErrors.flatMap((entry) => normalizePluginError(entry))
+            : [],
+        importSources: readStringArray(summary.importSources),
+        attachedClients: Array.isArray(summary.attachedClients)
+            ? summary.attachedClients.flatMap((entry) => normalizeAttachedClient(entry))
+            : [],
+        leaseHolderClientId: optionalString(summary.leaseHolderClientId),
+        watchState: isCodeSyncWatchState(summary.watchState) ? summary.watchState : undefined,
+        codeSyncState: isCodeSyncState(summary.codeSyncState) ? summary.codeSyncState : undefined,
+        boundFiles: readStringArray(summary.boundFiles),
+        conflictCount: optionalNumber(summary.conflictCount) ?? undefined,
+        driftState: isCodeSyncDriftState(summary.driftState) ? summary.driftState : undefined,
+        lastImportAt: optionalString(summary.lastImportAt) ?? undefined,
+        lastPushAt: optionalString(summary.lastPushAt) ?? undefined,
+        starterId: optionalString(summary.starterId),
+        starterName: optionalString(summary.starterName),
+        starterFrameworkId: optionalString(summary.starterFrameworkId),
+        starterAppliedAt: optionalString(summary.starterAppliedAt),
+        bindings: Array.isArray(summary.bindings)
+            ? summary.bindings.flatMap((entry) => normalizeCodeSyncBindingStatus(entry))
+            : [],
+        history: normalizeHistoryState(summary.history)
+    };
+}
+export function normalizeCanvasTargetStateSummaries(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.flatMap((entry) => {
+        if (!isRecord(entry)) {
+            return [];
+        }
+        const targetId = optionalString(entry.targetId);
+        const previewMode = normalizePreviewState(entry.previewMode);
+        const previewState = normalizePreviewState(entry.previewState);
+        if (!targetId || !previewMode || !previewState) {
+            return [];
+        }
+        return [{
+                targetId,
+                prototypeId: optionalString(entry.prototypeId),
+                previewMode,
+                previewState,
+                renderStatus: normalizeRenderStatus(entry.renderStatus) ?? undefined,
+                degradeReason: optionalString(entry.degradeReason),
+                lastRenderedAt: optionalString(entry.lastRenderedAt) ?? undefined,
+                projection: isCodeSyncProjectionMode(entry.projection) ? entry.projection : undefined,
+                fallbackReason: isCodeSyncFallbackReason(entry.fallbackReason) ? entry.fallbackReason : null,
+                parityArtifact: normalizeParityArtifact(entry.parityArtifact)
+            }];
+    });
+}
+export function summarizeCanvasProjectionState(summary, targets) {
+    const activeProjections = uniqueStrings([
+        ...targets.flatMap((entry) => entry.projection ? [entry.projection] : []),
+        ...summary.bindings.flatMap((entry) => entry.projection ? [entry.projection] : [])
+    ]);
+    const fallbackReasons = uniqueStrings(targets.flatMap((entry) => entry.fallbackReason ? [entry.fallbackReason] : []));
+    const conflictCount = typeof summary.conflictCount === "number"
+        ? summary.conflictCount
+        : summary.bindings.reduce((sum, entry) => sum + entry.conflictCount, 0);
+    return {
+        activeProjections,
+        fallbackReasons,
+        conflictCount,
+        watchConflict: summary.watchState === "watching" && (summary.driftState === "conflict" || conflictCount > 0)
+    };
+}
+export function summarizeCanvasHistoryState(summary) {
+    const history = summary.history;
+    if (!history) {
+        return "No history yet";
+    }
+    return [
+        `${history.undoDepth}/${history.depthLimit} undo`,
+        `${history.redoDepth} redo`,
+        history.stale ? "stale" : "ready"
+    ].join(" • ");
+}
+export function readLatestImportProvenance(summary, document) {
+    const latestImport = document.meta.imports.at(-1);
+    if (isRecord(latestImport)) {
+        const source = isRecord(latestImport.source) ? latestImport.source : null;
+        return [
+            optionalString(source?.label),
+            optionalString(source?.kind),
+            optionalString(source?.frameworkId)
+        ].filter((entry) => typeof entry === "string" && entry.length > 0).join(" • ");
+    }
+    return summary.importSources?.[0] ?? null;
+}
+export function readSelectedBindingIdentity(document, nodeId) {
+    if (!nodeId) {
+        return {
+            bindingId: null,
+            bindingKind: null,
+            componentName: null,
+            sourceKind: null,
+            framework: null,
+            adapter: null,
+            plugin: null
+        };
+    }
+    const node = findNodeById(document, nodeId);
+    const bindingId = typeof node?.bindingRefs.primary === "string" ? node.bindingRefs.primary : null;
+    const binding = bindingId ? document.bindings.find((entry) => entry.id === bindingId) ?? null : null;
+    const bindingMetadata = isRecord(binding?.metadata) ? binding.metadata : {};
+    const inventoryItem = document.componentInventory.find((entry) => {
+        if (binding?.componentName && entry.componentName === binding.componentName) {
+            return true;
+        }
+        return entry.id === optionalString(bindingMetadata.inventoryItemId);
+    }) ?? null;
+    return {
+        bindingId,
+        bindingKind: binding?.kind ?? null,
+        componentName: binding?.componentName ?? inventoryItem?.componentName ?? inventoryItem?.name ?? null,
+        sourceKind: optionalString(bindingMetadata.sourceKind) ?? inventoryItem?.sourceKind ?? null,
+        framework: inventoryItem?.framework?.label ?? inventoryItem?.framework?.id ?? null,
+        adapter: inventoryItem?.adapter?.label ?? inventoryItem?.adapter?.id ?? null,
+        plugin: inventoryItem?.plugin?.label ?? inventoryItem?.plugin?.id ?? null
+    };
+}
+function normalizeAttachedClient(value) {
+    if (!isRecord(value)) {
+        return [];
+    }
+    const clientId = optionalString(value.clientId);
+    const attachedAt = optionalString(value.attachedAt);
+    const lastSeenAt = optionalString(value.lastSeenAt);
+    if (!clientId || !attachedAt || !lastSeenAt) {
+        return [];
+    }
+    return [{
+            clientId,
+            role: ATTACHED_CLIENT_ROLES.has(value.role)
+                ? value.role
+                : "observer",
+            attachedAt,
+            lastSeenAt
+        }];
+}
+function normalizeCodeSyncBindingStatus(value) {
+    if (!isRecord(value)) {
+        return [];
+    }
+    const bindingId = optionalString(value.bindingId);
+    const nodeId = optionalString(value.nodeId);
+    const repoPath = optionalString(value.repoPath);
+    const adapter = optionalString(value.adapter);
+    const syncMode = optionalString(value.syncMode);
+    const projection = isCodeSyncProjectionMode(value.projection) ? value.projection : null;
+    const state = isCodeSyncState(value.state) ? value.state : null;
+    const driftState = isCodeSyncDriftState(value.driftState) ? value.driftState : null;
+    if (!bindingId || !nodeId || !repoPath || !adapter || !syncMode || !projection || !state || !driftState) {
+        return [];
+    }
+    return [{
+            bindingId,
+            nodeId,
+            repoPath,
+            adapter,
+            syncMode,
+            projection,
+            state,
+            driftState,
+            watchEnabled: value.watchEnabled === true,
+            lastImportedAt: optionalString(value.lastImportedAt) ?? undefined,
+            lastPushedAt: optionalString(value.lastPushedAt) ?? undefined,
+            conflictCount: optionalNumber(value.conflictCount) ?? 0,
+            unsupportedCount: optionalNumber(value.unsupportedCount) ?? 0
+        }];
+}
+function normalizeCapabilityGrant(value) {
+    if (!isRecord(value)) {
+        return [];
+    }
+    const capability = optionalString(value.capability);
+    if (!capability) {
+        return [];
+    }
+    return [{
+            capability,
+            granted: value.granted === true,
+            reason: optionalString(value.reason),
+            metadata: isRecord(value.metadata) ? value.metadata : {}
+        }];
+}
+function normalizePluginError(value) {
+    if (!isRecord(value)) {
+        return [];
+    }
+    const code = optionalString(value.code);
+    const message = optionalString(value.message);
+    if (!code || !message) {
+        return [];
+    }
+    return [{
+            pluginId: optionalString(value.pluginId),
+            code,
+            message,
+            details: isRecord(value.details) ? value.details : {}
+        }];
+}
+function normalizeHistoryState(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return {
+        canUndo: value.canUndo === true,
+        canRedo: value.canRedo === true,
+        undoDepth: optionalNumber(value.undoDepth) ?? 0,
+        redoDepth: optionalNumber(value.redoDepth) ?? 0,
+        stale: value.stale === true,
+        depthLimit: optionalNumber(value.depthLimit) ?? 100
+    };
+}
+function normalizeParityArtifact(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const projection = isCodeSyncProjectionMode(value.projection) ? value.projection : null;
+    const rootBindingId = optionalString(value.rootBindingId);
+    const capturedAt = optionalString(value.capturedAt);
+    const hierarchyHash = optionalString(value.hierarchyHash);
+    if (!projection || !rootBindingId || !capturedAt || !hierarchyHash) {
+        return null;
+    }
+    const nodeCount = Array.isArray(value.nodes)
+        ? value.nodes.length
+        : optionalNumber(value.nodeCount) ?? 0;
+    return {
+        projection,
+        rootBindingId,
+        capturedAt,
+        hierarchyHash,
+        nodeCount
+    };
+}
+function normalizePreviewState(value) {
+    return value === "focused" || value === "pinned" || value === "background" || value === "degraded"
+        ? value
+        : null;
+}
+function normalizeRenderStatus(value) {
+    return value === "idle" || value === "rendered" || value === "degraded"
+        ? value
+        : null;
+}
+function isCodeSyncState(value) {
+    return typeof value === "string" && CODE_SYNC_STATES.has(value);
+}
+function isCodeSyncDriftState(value) {
+    return typeof value === "string" && CODE_SYNC_DRIFT_STATES.has(value);
+}
+function isCodeSyncWatchState(value) {
+    return typeof value === "string" && CODE_SYNC_WATCH_STATES.has(value);
+}
+function isCodeSyncProjectionMode(value) {
+    return typeof value === "string" && CODE_SYNC_PROJECTIONS.has(value);
+}
+function isCodeSyncFallbackReason(value) {
+    return typeof value === "string" && CODE_SYNC_FALLBACK_REASONS.has(value);
+}
+function readStringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0)
+        : [];
+}
+function uniqueStrings(values) {
+    return [...new Set(values)];
+}
+function optionalString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function optionalNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function findNodeById(document, nodeId) {
+    for (const page of document.pages) {
+        const node = page.nodes.find((entry) => entry.id === nodeId);
+        if (node) {
+            return node;
+        }
+    }
+    return null;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/extension/dist/canvas/viewport-fit.js

@@ -0,0 +1,67 @@
+export const DEFAULT_EDITOR_VIEWPORT = {
+    x: 120,
+    y: 96,
+    zoom: 1
+};
+const MIN_ZOOM = 0.35;
+const MAX_ZOOM = 2.4;
+const DEFAULT_STAGE_WIDTH = 960;
+const DEFAULT_STAGE_HEIGHT = 640;
+const FIT_PADDING = 48;
+const clamp = (value, min, max) => {
+    return Math.min(Math.max(value, min), max);
+};
+const roundZoom = (value) => {
+    return Math.round(value * 100) / 100;
+};
+const resolveStageSize = (value, fallback) => {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+};
+export const isDefaultEditorViewport = (viewport) => {
+    return viewport.x === DEFAULT_EDITOR_VIEWPORT.x
+        && viewport.y === DEFAULT_EDITOR_VIEWPORT.y
+        && viewport.zoom === DEFAULT_EDITOR_VIEWPORT.zoom;
+};
+export const computeViewportCanvasCenter = (viewport, stageWidth, stageHeight) => {
+    const safeStageWidth = resolveStageSize(stageWidth, DEFAULT_STAGE_WIDTH);
+    const safeStageHeight = resolveStageSize(stageHeight, DEFAULT_STAGE_HEIGHT);
+    return {
+        x: (safeStageWidth / 2 - viewport.x) / viewport.zoom,
+        y: (safeStageHeight / 2 - viewport.y) / viewport.zoom
+    };
+};
+const computeNodeBounds = (nodes) => {
+    if (nodes.length === 0) {
+        return null;
+    }
+    const minX = Math.min(...nodes.map((node) => node.rect.x));
+    const minY = Math.min(...nodes.map((node) => node.rect.y));
+    const maxX = Math.max(...nodes.map((node) => node.rect.x + node.rect.width));
+    const maxY = Math.max(...nodes.map((node) => node.rect.y + node.rect.height));
+    return {
+        minX,
+        minY,
+        width: Math.max(maxX - minX, 1),
+        height: Math.max(maxY - minY, 1)
+    };
+};
+export const computeFittedViewport = (nodes, stageWidth, stageHeight) => {
+    const bounds = computeNodeBounds(nodes);
+    if (!bounds) {
+        return { ...DEFAULT_EDITOR_VIEWPORT };
+    }
+    const safeStageWidth = resolveStageSize(stageWidth, DEFAULT_STAGE_WIDTH);
+    const safeStageHeight = resolveStageSize(stageHeight, DEFAULT_STAGE_HEIGHT);
+    const availableWidth = Math.max(safeStageWidth - FIT_PADDING * 2, 160);
+    const availableHeight = Math.max(safeStageHeight - FIT_PADDING * 2, 160);
+    const nextZoom = clamp(Math.min(availableWidth / bounds.width, availableHeight / bounds.height, 1), MIN_ZOOM, MAX_ZOOM);
+    const zoom = roundZoom(nextZoom);
+    const centeredX = (safeStageWidth - bounds.width * zoom) / 2 - bounds.minX * zoom;
+    const centeredY = (safeStageHeight - bounds.height * zoom) / 2 - bounds.minY * zoom;
+    const anchoredY = DEFAULT_EDITOR_VIEWPORT.y - bounds.minY * zoom;
+    return {
+        x: Math.round(centeredX),
+        y: Math.round(Math.min(centeredY, anchoredY)),
+        zoom
+    };
+};