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

package/dist/lib/node-esm/NotebookContainer-QY5NJGJI.mjs

@@ -1,684 +0,0 @@
-import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  NotebookMenu,
-  NotebookStack
-} from "./chunk-67OVZHI3.mjs";
-import "./chunk-VRSDE4CI.mjs";
-import {
-  meta
-} from "./chunk-OG2SIKHE.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-QY5NJGJI.mjs.map