opendevbrowser 0.0.16 → 0.0.17

package/extension/dist/canvas/model.js

@@ -0,0 +1,213 @@
+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,
+        componentSourceKinds: readStringArray(summary.componentSourceKinds),
+        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,
+        bindings: Array.isArray(summary.bindings)
+            ? summary.bindings.flatMap((entry) => normalizeCodeSyncBindingStatus(entry))
+            : []
+    };
+}
+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)
+    };
+}
+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 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 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
+    };
+};