@dxos/plugin-script 0.8.4-main.dedc0f3 → 0.8.4-main.ead640a

package/dist/lib/browser/DeploymentDialog-65TWT6S5.mjs

@@ -0,0 +1,13 @@
+import {
+  DEPLOYMENT_DIALOG,
+  DeploymentDialog_default
+} from "./chunk-NM4WQS4F.mjs";
+import "./chunk-JO2O7W6J.mjs";
+import "./chunk-5CYLWXRH.mjs";
+import "./chunk-ST3ACVUC.mjs";
+import "./chunk-EZVXV6DA.mjs";
+export {
+  DEPLOYMENT_DIALOG,
+  DeploymentDialog_default as default
+};
+//# sourceMappingURL=DeploymentDialog-65TWT6S5.mjs.map

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

@@ -0,0 +1,683 @@
+import {
+  NotebookMenu,
+  NotebookStack
+} from "./chunk-75LH4EUR.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 { invariant as invariant2 } from "@dxos/invariant";
+import { Assistant } from "@dxos/plugin-assistant";
+import { getSpace } from "@dxos/react-client/echo";
+import { DropdownMenu, IconButton, 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/eval.ts
+import { trim } from "@dxos/util";
+var evalScript = (code, deps = {}) => {
+  const sandbox = {
+    ...deps,
+    // Block access to global objects.
+    console: void 0,
+    document: void 0,
+    global: void 0,
+    globalThis: void 0,
+    self: void 0,
+    window: void 0,
+    // Allow some safe globals.
+    Array,
+    Boolean,
+    Date,
+    Error,
+    JSON,
+    Map,
+    Math,
+    Number,
+    Object,
+    Promise,
+    RegExp,
+    Set,
+    String,
+    // Functions.
+    isFinite,
+    isNaN,
+    parseFloat,
+    parseInt
+  };
+  const sandboxKeys = Object.keys(sandbox);
+  const sandboxValues = Object.values(sandbox);
+  const fn = new Function(...sandboxKeys, trim`
+      'use strict';
+      return ${code};
+    `);
+  return fn(...sandboxValues);
+};
+var builtIns = /* @__PURE__ */ new Set([
+  // Types.
+  "Array",
+  "Date",
+  "Error",
+  "JSON",
+  "Map",
+  "Math",
+  "Number",
+  "Object",
+  "Promise",
+  "RegExp",
+  "Set",
+  "String",
+  // Functions.
+  "isFinite",
+  "isNaN",
+  "parseFloat",
+  "parseInt"
+]);
+var systemDefinitions = 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/vfs-parser.ts
+import { createSystem, createVirtualTypeScriptEnvironment } from "@typescript/vfs";
+import ts from "typescript";
+import { invariant } from "@dxos/invariant";
+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 systemFiles = [
+  {
+    filename: "/lib.d.ts",
+    content: systemDefinitions
+  }
+];
+var VirtualTypeScriptParser = class {
+  /**
+  * Parse a single expression or statement.
+  */
+  parseExpression(input) {
+    invariant(input.trim() !== "", "input must not be empty", {
+      F: __dxlog_file,
+      L: 57,
+      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
+        }
+      ]);
+      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);
+    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 = (node2) => {
+      if (ts.isFunctionDeclaration(node2) || ts.isArrowFunction(node2) || ts.isFunctionExpression(node2)) {
+        node2.parameters.forEach((param) => {
+          if (ts.isIdentifier(param.name)) {
+            localSymbols.add(param.name.text);
+          }
+        });
+      }
+      if (ts.isVariableDeclaration(node2) && ts.isIdentifier(node2.name)) {
+        localSymbols.add(node2.name.text);
+      }
+      ts.forEachChild(node2, collectLocalSymbols);
+    };
+    collectLocalSymbols(node);
+    const findRefs = (node2) => {
+      if (ts.isIdentifier(node2)) {
+        if (!localSymbols.has(node2.text)) {
+          const parent = node2.parent;
+          const isDeclaration = ts.isVariableDeclaration(parent) && parent.name === node2 || ts.isFunctionDeclaration(parent) && parent.name === node2 || ts.isParameter(parent) && parent.name === node2;
+          if (!isDeclaration && !this.isBuiltIn(node2.text)) {
+            references.add(node2.text);
+          }
+        }
+      }
+      ts.forEachChild(node2, 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 allFiles = [
+      ...systemFiles,
+      ...files
+    ];
+    const fileMap = /* @__PURE__ */ new Map();
+    allFiles.forEach(({ filename, content }) => {
+      fileMap.set(filename, content);
+    });
+    const system = createSystem(fileMap);
+    return createVirtualTypeScriptEnvironment(system, allFiles.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
+    });
+  }
+};
+
+// 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: 64,
+          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: 70,
+          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 = evalScript(rhs, valuesByName);
+            valuesByName[expr.name] = result;
+            if (typeof result !== "function") {
+              valuesByCellId[cellId] = result;
+            }
+          }
+        } else {
+          const result = evalScript(cellSource, valuesByName);
+          valuesByCellId[cellId] = result;
+        }
+      } catch (error) {
+        log.error("error evaluating cell", {
+          cellId,
+          error
+        }, {
+          F: __dxlog_file2,
+          L: 105,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    }
+    this._values.value = valuesByCellId;
+    return valuesByCellId;
+  }
+  /**
+  * Parse expressions.
+  */
+  parse() {
+    const expressions = this._notebook.cells.filter((cell) => cell.type === "script").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;
+  }
+  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 __dxlog_file3 = "/__w/dxos/dxos/packages/plugins/plugin-script/src/components/NotebookContainer.tsx";
+var NotebookContainer = ({ notebook, env }) => {
+  var _effect = _useSignals();
+  try {
+    const { t } = useTranslation(meta.id);
+    const space = getSpace(notebook);
+    const graph = useMemo(() => notebook && new ComputeGraph(notebook), [
+      notebook
+    ]);
+    const handleCompute = useCallback(() => {
+      graph?.evaluate();
+    }, [
+      graph
+    ]);
+    const handleRearrange = useCallback((source, target) => {
+      invariant2(notebook, void 0, {
+        F: __dxlog_file3,
+        L: 41,
+        S: void 0,
+        A: [
+          "notebook",
+          ""
+        ]
+      });
+      const from = notebook.cells.findIndex((cell) => cell.id === source.id);
+      const to = notebook.cells.findIndex((cell) => cell.id === target.id);
+      if (from != null && to != null) {
+        const cell = notebook.cells.splice(from, 1)[0];
+        if (cell) {
+          notebook.cells.splice(to, 0, cell);
+        }
+      }
+    }, [
+      notebook
+    ]);
+    const handleCellInsert = useCallback((type, after) => {
+      invariant2(notebook, void 0, {
+        F: __dxlog_file3,
+        L: 56,
+        S: void 0,
+        A: [
+          "notebook",
+          ""
+        ]
+      });
+      const cell = {
+        id: crypto.randomUUID(),
+        type
+      };
+      switch (type) {
+        case "markdown":
+        case "script":
+        case "query": {
+          cell.script = Ref.make(DataType.makeText());
+          break;
+        }
+        case "prompt": {
+          if (space) {
+            cell.chat = Ref.make(Assistant.makeChat({
+              queue: space.queues.create()
+            }));
+          }
+          break;
+        }
+      }
+      const idx = after ? notebook.cells.findIndex((cell2) => cell2.id === after) : notebook.cells.length;
+      notebook.cells.splice(idx, 0, cell);
+    }, [
+      space,
+      notebook
+    ]);
+    const handleCellDelete = useCallback((id) => {
+      invariant2(notebook, void 0, {
+        F: __dxlog_file3,
+        L: 82,
+        S: void 0,
+        A: [
+          "notebook",
+          ""
+        ]
+      });
+      const idx = notebook.cells.findIndex((cell) => cell.id === id);
+      if (idx !== -1) {
+        notebook.cells.splice(idx, 1);
+      }
+    }, [
+      notebook
+    ]);
+    return /* @__PURE__ */ React.createElement(StackItem.Content, {
+      toolbar: true
+    }, /* @__PURE__ */ React.createElement(Toolbar.Root, {
+      textBlockWidth: true
+    }, /* @__PURE__ */ React.createElement(DropdownMenu.Root, null, /* @__PURE__ */ React.createElement(DropdownMenu.Trigger, {
+      asChild: true
+    }, /* @__PURE__ */ React.createElement(IconButton, {
+      icon: "ph--plus--regular",
+      iconOnly: true,
+      label: t("notebook cell insert label")
+    })), /* @__PURE__ */ React.createElement(NotebookMenu, {
+      onCellInsert: 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("div", {
+      role: "none",
+      className: "flex bs-full overflow-hidden -mis-[1px] -mie-[1px]"
+    }, /* @__PURE__ */ React.createElement(NotebookStack, {
+      classNames: "container-max-width border-l border-r border-subduedSeparator",
+      space,
+      notebook,
+      graph,
+      env,
+      onRearrange: handleRearrange,
+      onCellInsert: handleCellInsert,
+      onCellDelete: handleCellDelete
+    })));
+  } finally {
+    _effect.f();
+  }
+};
+var NotebookContainer_default = NotebookContainer;
+export {
+  NotebookContainer,
+  NotebookContainer_default as default
+};
+//# sourceMappingURL=NotebookContainer-LVGRPFY3.mjs.map