@dxos/plugin-script 0.8.4-main.c1de068 → 0.8.4-main.c4373fc

package/dist/lib/browser/DeploymentDialog-7FNPALCV.mjs

@@ -0,0 +1,12 @@
+import {
+  DEPLOYMENT_DIALOG,
+  DeploymentDialog_default
+} from "./chunk-NNYSARXK.mjs";
+import "./chunk-ETFBQURU.mjs";
+import "./chunk-SWBZUZDX.mjs";
+import "./chunk-EZVXV6DA.mjs";
+export {
+  DEPLOYMENT_DIALOG,
+  DeploymentDialog_default as default
+};
+//# sourceMappingURL=DeploymentDialog-7FNPALCV.mjs.map

package/dist/lib/browser/NotebookContainer-ZSXYRRZB.mjs

@@ -0,0 +1,578 @@
+import {
+  NotebookStack
+} from "./chunk-I3THDIT5.mjs";
+import "./chunk-N6M34EUC.mjs";
+import {
+  meta
+} from "./chunk-EZVXV6DA.mjs";
+
+// src/components/NotebookContainer.tsx
+import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
+import React, { useCallback, useMemo } from "react";
+import { Ref } from "@dxos/echo";
+import { Toolbar, useTranslation } from "@dxos/react-ui";
+import { StackItem } from "@dxos/react-ui-stack";
+import { DataType } from "@dxos/schema";
+
+// src/notebook/notebook.ts
+import { signal } from "@preact/signals-core";
+import { log } from "@dxos/log";
+
+// src/notebook/vfs-parser.ts
+import { createSystem, createVirtualTypeScriptEnvironment } from "@typescript/vfs";
+import ts from "typescript";
+import { invariant } from "@dxos/invariant";
+import { trim } from "@dxos/util";
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-script/src/notebook/vfs-parser.ts";
+var VirtualTypeScriptParser = class {
+  /**
+  * Parse a single expression or statement.
+  */
+  parseExpression(input) {
+    invariant(input.trim() !== "", "input must not be empty", {
+      F: __dxlog_file,
+      L: 46,
+      S: this,
+      A: [
+        "input.trim() !== ''",
+        "'input must not be empty'"
+      ]
+    });
+    const files = [
+      {
+        filename: "/temp.ts",
+        content: input
+      }
+    ];
+    const analysis = this.analyzeFiles(files);
+    if (analysis.length === 0) {
+      const sourcefilename = "/temp.ts";
+      const env = this.createEnvironment([
+        {
+          filename: sourcefilename,
+          content: input
+        },
+        ...systemFiles
+      ]);
+      const sourceFile = env.getSourceFile(sourcefilename);
+      const typeChecker = env.languageService.getProgram()?.getTypeChecker();
+      if (sourceFile && typeChecker) {
+        const assignmentInfo = this.findAssignmentExpression(sourceFile, typeChecker);
+        if (assignmentInfo) {
+          return assignmentInfo;
+        }
+        const references = this.findAllReferences(sourceFile, typeChecker);
+        return {
+          references
+        };
+      }
+    }
+    return analysis[0];
+  }
+  /**
+  * Analyze multiple files with full type information.
+  */
+  analyzeFiles(files) {
+    const env = this.createEnvironment([
+      ...files,
+      ...systemFiles
+    ]);
+    const results = [];
+    const typeChecker = env.languageService.getProgram()?.getTypeChecker();
+    files.forEach((file) => {
+      const sourceFile = env.getSourceFile(file.filename);
+      if (!sourceFile || !typeChecker) return;
+      const fileResults = this.analyzeSourceFile(sourceFile, typeChecker);
+      results.push(...fileResults);
+    });
+    return results;
+  }
+  /**
+  * Analyze a source file with type information.
+  */
+  analyzeSourceFile(sourceFile, typeChecker) {
+    const results = [];
+    const visit = (node) => {
+      if (ts.isFunctionDeclaration(node) && node.name) {
+        const symbol = typeChecker.getSymbolAtLocation(node.name);
+        const type = symbol && typeChecker.getTypeOfSymbolAtLocation(symbol, node);
+        const signature = type && typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call)[0];
+        results.push({
+          name: node.name.text,
+          type: "function",
+          parameters: this.extractParameters(signature, typeChecker),
+          returnType: signature ? typeChecker.typeToString(signature.getReturnType()) : "any",
+          references: this.findReferences(node, sourceFile, typeChecker)
+        });
+      } else if (ts.isVariableStatement(node)) {
+        node.declarationList.declarations.forEach((declaration) => {
+          if (ts.isIdentifier(declaration.name)) {
+            const symbol = typeChecker.getSymbolAtLocation(declaration.name);
+            const type = symbol && typeChecker.getTypeOfSymbolAtLocation(symbol, declaration);
+            let kind = "variable";
+            let parameters;
+            let returnType;
+            let value;
+            const typeString = type ? typeChecker.typeToString(type) : "any";
+            if (declaration.initializer) {
+              if (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer)) {
+                kind = "function";
+                const funcType = typeChecker.getTypeAtLocation(declaration.initializer);
+                const signature = typeChecker.getSignaturesOfType(funcType, ts.SignatureKind.Call)[0];
+                if (signature) {
+                  parameters = this.extractParameters(signature, typeChecker);
+                  returnType = typeChecker.typeToString(signature.getReturnType());
+                }
+              } else {
+                if (ts.isNumericLiteral(declaration.initializer)) {
+                  value = Number(declaration.initializer.text);
+                } else if (ts.isStringLiteral(declaration.initializer)) {
+                  value = declaration.initializer.text;
+                }
+              }
+            }
+            const refs = declaration.initializer ? this.findReferences(declaration.initializer, sourceFile, typeChecker) : [];
+            results.push({
+              name: declaration.name.text,
+              type: kind,
+              valueType: typeString,
+              value,
+              parameters,
+              returnType,
+              references: refs
+            });
+          }
+        });
+      } else if (ts.isClassDeclaration(node) && node.name) {
+        results.push({
+          name: node.name.text,
+          type: "class",
+          references: this.findReferences(node, sourceFile, typeChecker)
+        });
+      } else if (ts.isInterfaceDeclaration(node)) {
+        results.push({
+          name: node.name.text,
+          type: "interface",
+          references: this.findReferences(node, sourceFile, typeChecker)
+        });
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return results;
+  }
+  /**
+  * Extract parameter information from a signature.
+  */
+  extractParameters(signature, typeChecker) {
+    if (!signature) return [];
+    return signature.parameters.map((param) => ({
+      name: param.getName(),
+      type: typeChecker.typeToString(typeChecker.getTypeOfSymbolAtLocation(param, param.valueDeclaration))
+    }));
+  }
+  /**
+  * Find all references to variables used in a node.
+  */
+  findReferences(node, _sourceFile, _typeChecker) {
+    const references = /* @__PURE__ */ new Set();
+    const localSymbols = /* @__PURE__ */ new Set();
+    const collectLocalSymbols = (n) => {
+      if (ts.isFunctionDeclaration(n) || ts.isArrowFunction(n) || ts.isFunctionExpression(n)) {
+        n.parameters.forEach((param) => {
+          if (ts.isIdentifier(param.name)) {
+            localSymbols.add(param.name.text);
+          }
+        });
+      }
+      if (ts.isVariableDeclaration(n) && ts.isIdentifier(n.name)) {
+        localSymbols.add(n.name.text);
+      }
+      ts.forEachChild(n, collectLocalSymbols);
+    };
+    collectLocalSymbols(node);
+    const findRefs = (n) => {
+      if (ts.isIdentifier(n)) {
+        if (!localSymbols.has(n.text)) {
+          const parent = n.parent;
+          const isDeclaration = ts.isVariableDeclaration(parent) && parent.name === n || ts.isFunctionDeclaration(parent) && parent.name === n || ts.isParameter(parent) && parent.name === n;
+          if (!isDeclaration && !this.isBuiltIn(n.text)) {
+            references.add(n.text);
+          }
+        }
+      }
+      ts.forEachChild(n, findRefs);
+    };
+    findRefs(node);
+    return Array.from(references);
+  }
+  /**
+  * Check if a name is a built-in global.
+  */
+  isBuiltIn(name) {
+    return builtIns.has(name);
+  }
+  /**
+  * Find assignment expressions in a source file.
+  */
+  findAssignmentExpression(sourceFile, typeChecker) {
+    let result = null;
+    const visit = (node) => {
+      if (ts.isExpressionStatement(node) && ts.isBinaryExpression(node.expression)) {
+        const expr = node.expression;
+        if (expr.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(expr.left)) {
+          const type = typeChecker.getTypeAtLocation(expr.right);
+          const typeString = typeChecker.typeToString(type);
+          let value;
+          if (ts.isNumericLiteral(expr.right)) {
+            value = Number(expr.right.text);
+          } else if (ts.isStringLiteral(expr.right)) {
+            value = expr.right.text;
+          }
+          const references = this.findReferences(expr.right, sourceFile, typeChecker);
+          result = {
+            name: expr.left.text,
+            type: "variable",
+            valueType: typeString,
+            value,
+            references
+          };
+        }
+      }
+      if (!result) {
+        ts.forEachChild(node, visit);
+      }
+    };
+    visit(sourceFile);
+    return result;
+  }
+  /**
+  * Find all identifier references in a source file.
+  */
+  findAllReferences(sourceFile, _typeChecker) {
+    const references = /* @__PURE__ */ new Set();
+    const visit = (node) => {
+      if (ts.isIdentifier(node)) {
+        const parent = node.parent;
+        const isDeclaration = ts.isVariableDeclaration(parent) && parent.name === node || ts.isFunctionDeclaration(parent) && parent.name === node || ts.isParameter(parent) && parent.name === node;
+        const isAssignmentTarget = ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && parent.left === node;
+        if (!isDeclaration && !isAssignmentTarget && !this.isBuiltIn(node.text)) {
+          references.add(node.text);
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return Array.from(references);
+  }
+  createEnvironment(files) {
+    const fileMap = /* @__PURE__ */ new Map();
+    files.forEach(({ filename, content }) => {
+      fileMap.set(filename, content);
+    });
+    const system = createSystem(fileMap);
+    return createVirtualTypeScriptEnvironment(system, files.map(({ filename }) => filename), ts, this.compilerOptions);
+  }
+  constructor() {
+    _define_property(this, "compilerOptions", {
+      target: ts.ScriptTarget.ES2020,
+      module: ts.ModuleKind.ESNext,
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInfilenames: true,
+      jsx: ts.JsxEmit.React,
+      noLib: true
+    });
+  }
+};
+var builtIns = /* @__PURE__ */ new Set([
+  // Types.
+  "Array",
+  "Date",
+  "Error",
+  "JSON",
+  "Map",
+  "Math",
+  "Number",
+  "Promise",
+  "Object",
+  "RegExp",
+  "Set",
+  "String",
+  // Functions.
+  "console",
+  "document",
+  "global",
+  "isFinite",
+  "isNaN",
+  "parseFloat",
+  "parseInt",
+  "process",
+  "window"
+]);
+var systemFiles = [
+  {
+    filename: "/lib.d.ts",
+    content: trim`
+      interface Array<T> { length: number; [n: number]: T; }
+      interface Boolean {}
+      interface Function {}
+      interface IArguments {}
+      interface Number {}
+      interface Object {}
+      interface RegExp {}
+      interface String { length: number; }
+      interface CallableFunction extends Function {}
+      interface NewableFunction extends Function {}
+      declare var console: { log(...args: any[]): void };
+    `
+  }
+];
+
+// src/notebook/notebook.ts
+function _define_property2(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var __dxlog_file2 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/notebook/notebook.ts";
+var ComputeGraph = class {
+  /**
+  * Parsed expressions by cell ID.
+  */
+  get expressions() {
+    return this._expressions;
+  }
+  /**
+  * Computed values by cell ID.
+  */
+  get values() {
+    return this._values;
+  }
+  /**
+  * Compute values.
+  */
+  evaluate() {
+    const { expressions, dependencyGraph } = this.parse();
+    this._values.value = {};
+    const cellExpressions = /* @__PURE__ */ new Map();
+    Object.entries(expressions).forEach(([id, expr]) => {
+      cellExpressions.set(id, expr);
+    });
+    const evaluationOrder = this.topologicalSort(Object.keys(expressions), dependencyGraph);
+    const valuesByName = {};
+    const valuesByCellId = {};
+    for (const cellId of evaluationOrder) {
+      const expr = cellExpressions.get(cellId);
+      if (!expr) {
+        log.error("no expression for cell", {
+          cellId
+        }, {
+          F: __dxlog_file2,
+          L: 63,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        continue;
+      }
+      const cellSource = this._notebook.cells.find((cell) => cell.id === cellId)?.script.target?.content;
+      if (!cellSource) {
+        log.error("no source for cell", {
+          cellId
+        }, {
+          F: __dxlog_file2,
+          L: 69,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        continue;
+      }
+      try {
+        if (expr.name && expr.value !== void 0) {
+          valuesByName[expr.name] = expr.value;
+          valuesByCellId[cellId] = expr.value;
+        } else if (expr.name) {
+          const equalIndex = cellSource.indexOf("=");
+          if (equalIndex !== -1) {
+            let rhs = cellSource.substring(equalIndex + 1).trim();
+            if (rhs.endsWith(";")) {
+              rhs = rhs.slice(0, -1).trim();
+            }
+            const result = this.evalScript(rhs, valuesByName);
+            valuesByName[expr.name] = result;
+            if (typeof result !== "function") {
+              valuesByCellId[cellId] = result;
+            }
+          }
+        } else {
+          const result = this.evalScript(cellSource, valuesByName);
+          valuesByCellId[cellId] = result;
+        }
+      } catch (error) {
+        log.error("error evaluating cell", {
+          cellId,
+          error
+        }, {
+          F: __dxlog_file2,
+          L: 104,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    }
+    this._values.value = valuesByCellId;
+    return valuesByCellId;
+  }
+  /**
+  * Parse expressions.
+  */
+  parse() {
+    const expressions = this._notebook.cells.reduce((acc, cell) => {
+      const text = cell.script.target?.content.trim();
+      if (text) {
+        const parsed = this._parser.parseExpression(text);
+        acc[cell.id] = parsed;
+      }
+      return acc;
+    }, {});
+    const dependencyGraph = this.buildDependencyGraph(expressions);
+    this._expressions.value = expressions;
+    return {
+      expressions,
+      dependencyGraph
+    };
+  }
+  topologicalSort(nodes, dependencies) {
+    const visited = /* @__PURE__ */ new Set();
+    const result = [];
+    const visit = (node) => {
+      if (visited.has(node)) {
+        return;
+      }
+      visited.add(node);
+      const deps = dependencies[node] || [];
+      deps.forEach((dep) => visit(dep));
+      result.push(node);
+    };
+    nodes.forEach((node) => visit(node));
+    return result;
+  }
+  buildDependencyGraph(expressions) {
+    const nameToCellId = /* @__PURE__ */ new Map();
+    Object.entries(expressions).forEach(([id, expr]) => {
+      if (expr.name) {
+        nameToCellId.set(expr.name, id);
+      }
+    });
+    const graph = {};
+    Object.entries(expressions).forEach(([id, expr]) => {
+      if (expr.references && expr.references.length > 0) {
+        const dependencyCellIds = expr.references.map((ref) => nameToCellId.get(ref)).filter((cellId) => cellId !== void 0 && cellId !== id);
+        if (dependencyCellIds.length > 0) {
+          graph[id] = dependencyCellIds;
+        }
+      }
+    });
+    return graph;
+  }
+  /**
+  * Evaluate the script (with dependencies as arguments).
+  */
+  evalScript(code, deps = {}) {
+    return new Function(...Object.keys(deps), "return " + code)(...Object.values(deps));
+  }
+  constructor(_notebook) {
+    _define_property2(this, "_notebook", void 0);
+    _define_property2(this, "_parser", void 0);
+    _define_property2(this, "_expressions", void 0);
+    _define_property2(this, "_values", void 0);
+    this._notebook = _notebook;
+    this._parser = new VirtualTypeScriptParser();
+    this._expressions = signal({});
+    this._values = signal({});
+  }
+};
+
+// src/components/NotebookContainer.tsx
+var NotebookContainer = ({ notebook, env }) => {
+  var _effect = _useSignals();
+  try {
+    const { t } = useTranslation(meta.id);
+    const graph = useMemo(() => notebook && new ComputeGraph(notebook), [
+      notebook
+    ]);
+    const handleCompute = useCallback(() => {
+      graph?.evaluate();
+    }, [
+      graph
+    ]);
+    const handleCellInsert = useCallback((after) => {
+      const idx = after ? notebook.cells.findIndex((cell) => cell.id === after) : notebook.cells.length;
+      notebook?.cells.splice(idx, 0, {
+        id: crypto.randomUUID(),
+        script: Ref.make(DataType.makeText("\n\n\n"))
+      });
+    }, [
+      notebook
+    ]);
+    const handleCellDelete = useCallback((id) => {
+      const idx = notebook.cells.findIndex((cell) => cell.id === id);
+      if (idx !== -1) {
+        notebook.cells.splice(idx, 1);
+      }
+    }, [
+      notebook
+    ]);
+    return /* @__PURE__ */ React.createElement(StackItem.Content, {
+      classNames: "container-max-width border-l border-r border-subduedSeparator",
+      toolbar: true
+    }, /* @__PURE__ */ React.createElement(Toolbar.Root, null, /* @__PURE__ */ React.createElement(Toolbar.IconButton, {
+      icon: "ph--plus--regular",
+      iconOnly: true,
+      label: t("add cell label"),
+      onClick: () => handleCellInsert("")
+    }), /* @__PURE__ */ React.createElement(Toolbar.IconButton, {
+      icon: "ph--play--fill",
+      iconOnly: true,
+      label: t("compute label"),
+      classNames: "text-green-500",
+      onClick: handleCompute
+    })), /* @__PURE__ */ React.createElement(NotebookStack, {
+      notebook,
+      graph,
+      env,
+      onCellInsert: handleCellInsert,
+      onCellDelete: handleCellDelete
+    }));
+  } finally {
+    _effect.f();
+  }
+};
+var NotebookContainer_default = NotebookContainer;
+export {
+  NotebookContainer,
+  NotebookContainer_default as default
+};
+//# sourceMappingURL=NotebookContainer-ZSXYRRZB.mjs.map