@lvce-editor/extension-host-worker 8.24.0 → 8.26.0

package/dist/extension-api/index.js

@@ -997,6 +997,175 @@ var create7 = (rpcId) => {
   };
 };
 
+// packages/extension-api/node_modules/@lvce-editor/constants/dist/parts/VirtualDomElements/VirtualDomElements.js
+var VirtualDomElements_exports = {};
+__export(VirtualDomElements_exports, {
+  A: () => A,
+  Abbr: () => Abbr,
+  Article: () => Article,
+  Aside: () => Aside,
+  Audio: () => Audio,
+  BlockQuote: () => BlockQuote,
+  Br: () => Br,
+  Button: () => Button,
+  Canvas: () => Canvas,
+  Circle: () => Circle,
+  Cite: () => Cite,
+  Code: () => Code,
+  Col: () => Col,
+  ColGroup: () => ColGroup,
+  Data: () => Data,
+  Dd: () => Dd,
+  Defs: () => Defs,
+  Del: () => Del,
+  Div: () => Div,
+  Dl: () => Dl,
+  Dt: () => Dt,
+  Ellipse: () => Ellipse,
+  Em: () => Em,
+  Figcaption: () => Figcaption,
+  Figure: () => Figure,
+  Footer: () => Footer,
+  Form: () => Form,
+  G: () => G,
+  H1: () => H1,
+  H2: () => H2,
+  H3: () => H3,
+  H4: () => H4,
+  H5: () => H5,
+  H6: () => H6,
+  Head: () => Head,
+  Header: () => Header,
+  Hr: () => Hr,
+  Html: () => Html,
+  I: () => I,
+  Iframe: () => Iframe,
+  Img: () => Img,
+  Input: () => Input,
+  Ins: () => Ins,
+  Kbd: () => Kbd,
+  Label: () => Label,
+  Li: () => Li,
+  Line: () => Line,
+  Main: () => Main,
+  Meta: () => Meta,
+  Nav: () => Nav,
+  Ol: () => Ol,
+  Option: () => Option,
+  P: () => P,
+  Path: () => Path,
+  Polygon: () => Polygon,
+  Polyline: () => Polyline,
+  Pre: () => Pre,
+  Quote: () => Quote,
+  Rect: () => Rect,
+  Reference: () => Reference,
+  Root: () => Root,
+  Search: () => Search,
+  Section: () => Section,
+  Select: () => Select,
+  Span: () => Span,
+  Strong: () => Strong,
+  Style: () => Style,
+  Svg: () => Svg,
+  TBody: () => TBody,
+  THead: () => THead,
+  Table: () => Table,
+  Td: () => Td,
+  Text: () => Text,
+  TextArea: () => TextArea,
+  Tfoot: () => Tfoot,
+  Th: () => Th,
+  Time: () => Time,
+  Title: () => Title,
+  Tr: () => Tr,
+  Ul: () => Ul,
+  Use: () => Use,
+  Video: () => Video
+});
+var Audio = 0;
+var Button = 1;
+var Col = 2;
+var ColGroup = 3;
+var Div = 4;
+var H1 = 5;
+var Input = 6;
+var Kbd = 7;
+var Span = 8;
+var Table = 9;
+var TBody = 10;
+var Td = 11;
+var Text = 12;
+var Th = 13;
+var THead = 14;
+var Tr = 15;
+var I = 16;
+var Img = 17;
+var Root = 0;
+var Ins = 20;
+var Del = 21;
+var H2 = 22;
+var H3 = 23;
+var H4 = 24;
+var H5 = 25;
+var H6 = 26;
+var Article = 27;
+var Aside = 28;
+var Footer = 29;
+var Header = 30;
+var Nav = 40;
+var Section = 41;
+var Search = 42;
+var Dd = 43;
+var Dl = 44;
+var Figcaption = 45;
+var Figure = 46;
+var Hr = 47;
+var Li = 48;
+var Ol = 49;
+var P = 50;
+var Pre = 51;
+var A = 53;
+var Abbr = 54;
+var Br = 55;
+var Cite = 56;
+var Data = 57;
+var Time = 58;
+var Tfoot = 59;
+var Ul = 60;
+var Video = 61;
+var TextArea = 62;
+var Select = 63;
+var Option = 64;
+var Code = 65;
+var Label = 66;
+var Dt = 67;
+var Iframe = 68;
+var Main = 69;
+var Strong = 70;
+var Em = 71;
+var Style = 72;
+var Html = 73;
+var Head = 74;
+var Title = 75;
+var Meta = 76;
+var Canvas = 77;
+var Form = 78;
+var BlockQuote = 79;
+var Quote = 80;
+var Circle = 81;
+var Defs = 82;
+var Ellipse = 83;
+var G = 84;
+var Line = 85;
+var Path = 86;
+var Polygon = 87;
+var Polyline = 88;
+var Rect = 89;
+var Svg = 90;
+var Use = 91;
+var Reference = 100;
+
 // packages/extension-api/node_modules/@lvce-editor/constants/dist/parts/RpcId/RpcId.js
 var RpcId_exports = {};
 __export(RpcId_exports, {
@@ -1215,7 +1384,9 @@ var registerCommand = (command) => {
 };
 var getCommandRegistrySnapshot = () => {
   return {
-    commands: Object.values(commands2)
+    commands: Object.values(commands2).map((command) => ({
+      id: command.id
+    }))
   };
 };
 var executeCommand = async (id2, ...args) => {
@@ -1329,16 +1500,40 @@ var getType = (value) => {
   }
   return typeof value;
 };
+var sanitizeCompletionItem = (item) => {
+  const sanitizedItem = {};
+  for (const [key, value] of Object.entries(item)) {
+    if (typeof value !== "function") {
+      sanitizedItem[key] = value;
+    }
+  }
+  const { kind: itemKind, type } = item;
+  let kind = 0;
+  if (typeof itemKind === "number") {
+    kind = itemKind;
+  } else if (typeof type === "number") {
+    kind = type;
+  }
+  return {
+    ...sanitizedItem,
+    flags: typeof item.flags === "number" ? item.flags : 0,
+    kind,
+    label: typeof item.label === "string" ? item.label : "",
+    matches: Array.isArray(item.matches) ? item.matches : []
+  };
+};
 var validateCompletionResult = (completion) => {
   if (!Array.isArray(completion)) {
     throw new ExtensionApiError(`invalid completion result: completion must be of type array but is ${getType(completion)}`);
   }
+  const completionItems = [];
   for (const item of completion) {
     if (!item || typeof item !== "object" || Array.isArray(item)) {
       throw new ExtensionApiError(`invalid completion result: expected completion item to be of type object but was of type ${getType(item)}`);
     }
+    completionItems.push(sanitizeCompletionItem(item));
   }
-  return completion;
+  return completionItems;
 };
 var registry = createProviderRegistry({
   mapProvider(provider) {
@@ -1383,7 +1578,10 @@ var executeResolveCompletionItemProvider = async (textDocument, offset, name, co
 var getCompletionProviders = registry.getProviders;
 var getCompletionProviderRegistrySnapshot = () => {
   return {
-    providers: registry.getProviders()
+    providers: registry.getProviders().map((provider) => ({
+      id: provider.id,
+      languageId: provider.languageId
+    }))
   };
 };
 var resetCompletionProviderRegistry = registry.reset;
@@ -1441,7 +1639,10 @@ var executeDiagnosticProvider = async (textDocument, ...args) => {
 var getDiagnosticProviders = registry2.getProviders;
 var getDiagnosticProviderRegistrySnapshot = () => {
   return {
-    providers: registry2.getProviders()
+    providers: registry2.getProviders().map((provider) => ({
+      id: provider.id,
+      languageId: provider.languageId
+    }))
   };
 };
 var resetDiagnosticProviderRegistry = registry2.reset;
@@ -1476,7 +1677,10 @@ var executeFormattingProvider = async (textDocument, ...args) => {
 var getFormattingProviders = registry3.getProviders;
 var getFormattingProviderRegistrySnapshot = () => {
   return {
-    providers: registry3.getProviders()
+    providers: registry3.getProviders().map((provider) => ({
+      id: provider.id,
+      languageId: provider.languageId
+    }))
   };
 };
 var resetFormattingProviderRegistry = registry3.reset;
@@ -1525,7 +1729,9 @@ var getStatusBarItems = () => {
 };
 var getStatusBarItemProviderRegistrySnapshot = () => {
   return {
-    providers: registry4.getProviders()
+    providers: registry4.getProviders().map((provider) => ({
+      id: provider.id
+    }))
   };
 };
 var resetStatusBarItemProviderRegistry = registry4.reset;
@@ -1581,7 +1787,10 @@ var executeHoverProvider = async (textDocument, offset, ...args) => {
 var getHoverProviders = registry5.getProviders;
 var getHoverProviderRegistrySnapshot = () => {
   return {
-    providers: registry5.getProviders()
+    providers: registry5.getProviders().map((provider) => ({
+      id: provider.id,
+      languageId: provider.languageId
+    }))
   };
 };
 var resetHoverProviderRegistry = registry5.reset;
@@ -1651,8 +1860,256 @@ var resetOutputChannelRegistry = () => {
   isActivated = false;
 };
 
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/PatchType/PatchType.js
+var SetText = 1;
+var Replace = 2;
+var SetAttribute = 3;
+var RemoveAttribute = 4;
+var Add = 6;
+var NavigateChild = 7;
+var NavigateParent = 8;
+var RemoveChild = 9;
+var NavigateSibling = 10;
+var SetReferenceNodeUid = 11;
+
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/IsKey/IsKey.js
+var isKey = (key) => {
+  return key !== "type" && key !== "childCount";
+};
+
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/GetKeys/GetKeys.js
+var getKeys = (node) => {
+  const keys = Object.keys(node).filter(isKey);
+  return keys;
+};
+
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/VirtualDomTree/VirtualDomTree.js
+var arrayToTree = (nodes) => {
+  const result = [];
+  let i = 0;
+  while (i < nodes.length) {
+    const node = nodes[i];
+    const { children, nodesConsumed } = getChildrenWithCount(nodes, i + 1, node.childCount || 0);
+    result.push({
+      node,
+      children
+    });
+    i += 1 + nodesConsumed;
+  }
+  return result;
+};
+var getChildrenWithCount = (nodes, startIndex, childCount) => {
+  if (childCount === 0) {
+    return { children: [], nodesConsumed: 0 };
+  }
+  const children = [];
+  let i = startIndex;
+  let remaining = childCount;
+  let totalConsumed = 0;
+  while (remaining > 0 && i < nodes.length) {
+    const node = nodes[i];
+    const nodeChildCount = node.childCount || 0;
+    const { children: nodeChildren, nodesConsumed } = getChildrenWithCount(nodes, i + 1, nodeChildCount);
+    children.push({
+      node,
+      children: nodeChildren
+    });
+    const nodeSize = 1 + nodesConsumed;
+    i += nodeSize;
+    totalConsumed += nodeSize;
+    remaining--;
+  }
+  return { children, nodesConsumed: totalConsumed };
+};
+
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/VirtualDomDiffTree/CompareNodes.js
+var compareNodes = (oldNode, newNode) => {
+  if (oldNode.type !== newNode.type) {
+    return null;
+  }
+  const patches = [];
+  if (oldNode.type === VirtualDomElements_exports.Reference) {
+    if (oldNode.uid !== newNode.uid) {
+      patches.push({
+        type: SetReferenceNodeUid,
+        uid: newNode.uid
+      });
+    }
+    return patches;
+  }
+  if (oldNode.type === VirtualDomElements_exports.Text && newNode.type === VirtualDomElements_exports.Text) {
+    if (oldNode.text !== newNode.text) {
+      patches.push({
+        type: SetText,
+        value: newNode.text
+      });
+    }
+    return patches;
+  }
+  const oldKeys = getKeys(oldNode);
+  const newKeys = getKeys(newNode);
+  for (const key of newKeys) {
+    if (oldNode[key] !== newNode[key]) {
+      patches.push({
+        type: SetAttribute,
+        key,
+        value: newNode[key]
+      });
+    }
+  }
+  for (const key of oldKeys) {
+    if (!Object.hasOwn(newNode, key)) {
+      patches.push({
+        type: RemoveAttribute,
+        key
+      });
+    }
+  }
+  return patches;
+};
+
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/VirtualDomDiffTree/TreeToArray.js
+var treeToArray = (node) => {
+  const result = [node.node];
+  for (const child of node.children) {
+    result.push(...treeToArray(child));
+  }
+  return result;
+};
+
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/VirtualDomDiffTree/DiffTrees.js
+var navigateToChild = (patches, currentChildIndex, index) => {
+  if (currentChildIndex === -1) {
+    patches.push({
+      type: NavigateChild,
+      index
+    });
+    return index;
+  }
+  if (currentChildIndex !== index) {
+    patches.push({
+      type: NavigateSibling,
+      index
+    });
+  }
+  return index;
+};
+var navigateToParent = (patches, currentChildIndex) => {
+  if (currentChildIndex >= 0) {
+    patches.push({
+      type: NavigateParent
+    });
+  }
+  return -1;
+};
+var addTree = (newNode, patches) => {
+  patches.push({
+    type: Add,
+    nodes: treeToArray(newNode)
+  });
+};
+var replaceTree = (newNode, patches) => {
+  patches.push({
+    type: Replace,
+    nodes: treeToArray(newNode)
+  });
+};
+var diffExistingChild = (oldNode, newNode, patches, currentChildIndex, index) => {
+  const nodePatches = compareNodes(oldNode.node, newNode.node);
+  if (nodePatches === null) {
+    const nextChildIndex2 = navigateToChild(patches, currentChildIndex, index);
+    replaceTree(newNode, patches);
+    return nextChildIndex2;
+  }
+  const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
+  if (nodePatches.length === 0 && !hasChildrenToCompare) {
+    return currentChildIndex;
+  }
+  const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
+  if (nodePatches.length > 0) {
+    patches.push(...nodePatches);
+  }
+  if (hasChildrenToCompare) {
+    diffChildren(oldNode.children, newNode.children, patches);
+  }
+  return nextChildIndex;
+};
+var diffRootNode = (oldNode, newNode, patches) => {
+  const nodePatches = compareNodes(oldNode.node, newNode.node);
+  if (nodePatches === null) {
+    replaceTree(newNode, patches);
+    return;
+  }
+  if (nodePatches.length > 0) {
+    patches.push(...nodePatches);
+  }
+  if (oldNode.children.length > 0 || newNode.children.length > 0) {
+    diffChildren(oldNode.children, newNode.children, patches);
+  }
+};
+var diffChildren = (oldChildren, newChildren, patches) => {
+  const maxLength = Math.max(oldChildren.length, newChildren.length);
+  let currentChildIndex = -1;
+  const indicesToRemove = [];
+  for (let i = 0; i < maxLength; i++) {
+    const oldNode = oldChildren[i];
+    const newNode = newChildren[i];
+    if (!oldNode && !newNode) {
+      continue;
+    }
+    if (!oldNode) {
+      currentChildIndex = navigateToParent(patches, currentChildIndex);
+      addTree(newNode, patches);
+      continue;
+    }
+    if (!newNode) {
+      indicesToRemove.push(i);
+      continue;
+    }
+    currentChildIndex = diffExistingChild(oldNode, newNode, patches, currentChildIndex, i);
+  }
+  navigateToParent(patches, currentChildIndex);
+  for (let j = indicesToRemove.length - 1; j >= 0; j--) {
+    patches.push({
+      type: RemoveChild,
+      index: indicesToRemove[j]
+    });
+  }
+};
+var diffTrees = (oldTree, newTree, patches, path) => {
+  if (path.length === 0 && oldTree.length === 1 && newTree.length === 1) {
+    diffRootNode(oldTree[0], newTree[0], patches);
+    return;
+  }
+  diffChildren(oldTree, newTree, patches);
+};
+
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/VirtualDomDiffTree/RemoveTrailingNavigationPatches.js
+var removeTrailingNavigationPatches = (patches) => {
+  let lastNonNavigationIndex = -1;
+  for (let i = patches.length - 1; i >= 0; i--) {
+    const patch = patches[i];
+    if (patch.type !== NavigateChild && patch.type !== NavigateParent && patch.type !== NavigateSibling) {
+      lastNonNavigationIndex = i;
+      break;
+    }
+  }
+  return lastNonNavigationIndex === -1 ? [] : patches.slice(0, lastNonNavigationIndex + 1);
+};
+
+// packages/extension-api/node_modules/@lvce-editor/virtual-dom-worker/dist/parts/VirtualDomDiffTree/VirtualDomDiffTree.js
+var diffTree = (oldNodes, newNodes) => {
+  const oldTree = arrayToTree(oldNodes);
+  const newTree = arrayToTree(newNodes);
+  const patches = [];
+  diffTrees(oldTree, newTree, patches, []);
+  return removeTrailingNavigationPatches(patches);
+};
+
 // packages/extension-api/src/parts/ViewRegistry/ViewRegistry.ts
 var views = /* @__PURE__ */ Object.create(null);
+var instances = /* @__PURE__ */ Object.create(null);
+var renderedDoms = /* @__PURE__ */ Object.create(null);
 var assertView = (view) => {
   if (!view) {
     throw new ExtensionApiError("view is not defined");
@@ -1668,11 +2125,18 @@ var assertView = (view) => {
   }
 };
 var toRegisteredView = (view) => {
-  return {
+  const registeredView = {
     icon: view.icon,
     id: view.id,
     title: view.title
   };
+  if (view.kind) {
+    return {
+      ...registeredView,
+      kind: view.kind
+    };
+  }
+  return registeredView;
 };
 var registerView = (view) => {
   assertView(view);
@@ -1690,6 +2154,79 @@ var executeViewProvider = (id2) => {
   }
   return view.create();
 };
+var assertVirtualDomViewInstance = (id2, instance) => {
+  if (!instance || typeof instance !== "object") {
+    throw new ExtensionApiError(`view ${id2} did not return a view instance`);
+  }
+  if (typeof instance.render !== "function") {
+    throw new ExtensionApiError(`view ${id2} instance is missing render function`);
+  }
+};
+var getVirtualDomInstance = (uid) => {
+  const instance = instances[uid];
+  if (!instance) {
+    throw new ExtensionApiError(`view instance ${uid} not found`);
+  }
+  return instance;
+};
+var renderDom = async (instance) => {
+  const dom = await instance.render();
+  if (!Array.isArray(dom)) {
+    throw new ExtensionApiError("view render result must be an array");
+  }
+  return dom;
+};
+var createViewInstance = async (viewId, uid, context) => {
+  const view = views[viewId];
+  if (!view) {
+    throw new ExtensionApiError(`view ${viewId} not found`);
+  }
+  if (view.kind !== "virtualDom") {
+    throw new ExtensionApiError(`view ${viewId} is not a virtual dom view`);
+  }
+  const instance = await view.create({
+    ...context,
+    uid,
+    viewId
+  });
+  assertVirtualDomViewInstance(viewId, instance);
+  instances[uid] = instance;
+  const dom = await renderDom(instance);
+  renderedDoms[uid] = dom;
+  return {
+    dom,
+    type: "setDom"
+  };
+};
+var dispatchViewEvent = async (uid, event) => {
+  const instance = getVirtualDomInstance(uid);
+  if (typeof instance.handleEvent === "function") {
+    await instance.handleEvent(event);
+  }
+  const oldDom = renderedDoms[uid] || [];
+  const newDom = await renderDom(instance);
+  renderedDoms[uid] = newDom;
+  const patches = diffTree(oldDom, newDom);
+  return {
+    patches,
+    type: "setPatches"
+  };
+};
+var disposeViewInstance = async (uid) => {
+  const instance = instances[uid];
+  if (instance && typeof instance.dispose === "function") {
+    await instance.dispose();
+  }
+  delete instances[uid];
+  delete renderedDoms[uid];
+};
+var saveViewInstanceState = async (uid) => {
+  const instance = getVirtualDomInstance(uid);
+  if (typeof instance.saveState !== "function") {
+    return void 0;
+  }
+  return instance.saveState();
+};
 var getViewRegistrySnapshot = () => {
   return {
     views: Object.values(views).map(toRegisteredView)
@@ -1699,10 +2236,19 @@ var resetViewRegistry = () => {
   for (const id2 of Object.keys(views)) {
     delete views[id2];
   }
+  for (const uid of Object.keys(instances)) {
+    delete instances[Number(uid)];
+  }
+  for (const uid of Object.keys(renderedDoms)) {
+    delete renderedDoms[Number(uid)];
+  }
 };
 
 // packages/extension-api/src/parts/ExtensionApiCommandMap/ExtensionApiCommandMap.ts
 var commandMap = {
+  "ExtensionApi.createViewInstance": createViewInstance,
+  "ExtensionApi.dispatchViewEvent": dispatchViewEvent,
+  "ExtensionApi.disposeViewInstance": disposeViewInstance,
   "ExtensionApi.executeCommand": executeCommand,
   "ExtensionApi.executeCompletionProvider": executeCompletionProvider,
   "ExtensionApi.executeDiagnosticProvider": executeDiagnosticProvider,
@@ -1717,7 +2263,8 @@ var commandMap = {
   "ExtensionApi.getHoverProviderRegistrySnapshot": getHoverProviderRegistrySnapshot,
   "ExtensionApi.getOutputChannelRegistrySnapshot": getOutputChannelRegistrySnapshot,
   "ExtensionApi.getStatusBarItems": getStatusBarItems,
-  "ExtensionApi.getViewRegistrySnapshot": getViewRegistrySnapshot
+  "ExtensionApi.getViewRegistrySnapshot": getViewRegistrySnapshot,
+  "ExtensionApi.saveViewInstanceState": saveViewInstanceState
 };
 
 // packages/extension-api/src/parts/ExtensionApiWorkerHandleMessagePort/ExtensionApiWorkerHandleMessagePort.ts
@@ -1807,6 +2354,9 @@ var handleExtensionManagementMessagePort2 = async ({
 export {
   activate,
   createOutputChannel,
+  createViewInstance,
+  dispatchViewEvent,
+  disposeViewInstance,
   executeCommand2 as executeCommand,
   executeCompletionProvider,
   executeDiagnosticProvider,
@@ -1836,5 +2386,6 @@ export {
   resetOutputChannelRegistry,
   resetStatusBarItemProviderRegistry,
   resetViewRegistry,
+  saveViewInstanceState,
   showQuickPick
 };

package/dist/extension-api/parts/CommandRegistry/CommandRegistry.js

@@ -30,7 +30,9 @@ const registerCommand = (command) => {
 };
 const getCommandRegistrySnapshot = () => {
   return {
-    commands: Object.values(commands)
+    commands: Object.values(commands).map((command) => ({
+      id: command.id
+    }))
   };
 };
 const executeCommand = async (id, ...args) => {