@dxos/plugin-debug 0.8.3 → 0.8.4-main.1068cf700f

package/dist/lib/browser/SpaceGenerator-VB6IB2LL.mjs

@@ -1,1238 +0,0 @@
-// packages/plugins/plugin-debug/src/components/SpaceGenerator/SpaceGenerator.tsx
-import { useSignals as _useSignals2 } from "@preact-signals/safe-react/tracking";
-import React2, { useCallback, useMemo, useState } from "react";
-import { createIntent, useIntentDispatcher } from "@dxos/app-framework";
-import { ComputeGraph as ComputeGraph2 } from "@dxos/conductor";
-import { Filter as Filter3, Obj as Obj3, Type as Type2 } from "@dxos/echo";
-import { log } from "@dxos/log";
-import { DocumentType as DocumentType2 } from "@dxos/plugin-markdown/types";
-import { SheetType as SheetType2 } from "@dxos/plugin-sheet/types";
-import { DiagramType as DiagramType2 } from "@dxos/plugin-sketch/types";
-import { SpaceAction } from "@dxos/plugin-space/types";
-import { useClient } from "@dxos/react-client";
-import { getTypename } from "@dxos/react-client/echo";
-import { IconButton as IconButton2, Input, Toolbar, useAsyncEffect } from "@dxos/react-ui";
-import { SyntaxHighlighter } from "@dxos/react-ui-syntax-highlighter";
-import { initializeTable, TableType as TableType3 } from "@dxos/react-ui-table";
-import { DataType as DataType2 } from "@dxos/schema";
-import { jsonKeyReplacer, sortKeys } from "@dxos/util";
-
-// packages/plugins/plugin-debug/src/components/SpaceGenerator/ObjectGenerator.tsx
-import { addressToA1Notation } from "@dxos/compute";
-import { ComputeGraph, ComputeGraphModel, DEFAULT_OUTPUT, NODE_INPUT, NODE_OUTPUT } from "@dxos/conductor";
-import { DXN, Filter, Key, Obj, Ref } from "@dxos/echo";
-import { DocumentType } from "@dxos/plugin-markdown/types";
-import { createSheet } from "@dxos/plugin-sheet/types";
-import { SheetType } from "@dxos/plugin-sheet/types";
-import { CanvasType, DiagramType } from "@dxos/plugin-sketch/types";
-import { faker } from "@dxos/random";
-import { TableType } from "@dxos/react-ui-table";
-import { createView, DataType } from "@dxos/schema";
-import { createAsyncGenerator } from "@dxos/schema/testing";
-import { range } from "@dxos/util";
-var generator = faker;
-var createGenerator = (type) => {
-  return async (space, n, cb) => {
-    const schema = await space.db.schemaRegistry.query({
-      typename: type.typename
-    }).firstOrUndefined() ?? (await space.db.schemaRegistry.register([
-      type
-    ]))[0];
-    const generate = createAsyncGenerator(generator, schema.snapshot, {
-      db: space.db
-    });
-    const objects = await generate.createObjects(n);
-    const { objects: tables } = await space.db.query(Filter.type(TableType)).run();
-    const table = tables.find((table2) => table2.view?.target?.query?.typename === type.typename);
-    if (!table) {
-      const name = type.typename.split("/").pop() ?? type.typename;
-      const view = createView({
-        name,
-        typename: type.typename,
-        jsonSchema: schema.jsonSchema
-      });
-      space.db.add(Obj.make(TableType, {
-        name,
-        view: Ref.make(view)
-      }));
-    }
-    return objects;
-  };
-};
-var staticGenerators = /* @__PURE__ */ new Map([
-  [
-    DocumentType.typename,
-    async (space, n, cb) => {
-      const objects = range(n).map(() => {
-        return space.db.add(Obj.make(DocumentType, {
-          name: faker.commerce.productName(),
-          content: Ref.make(Obj.make(DataType.Text, {
-            content: faker.lorem.sentences(5)
-          }))
-        }));
-      });
-      cb?.(objects);
-      return objects;
-    }
-  ],
-  [
-    DiagramType.typename,
-    async (space, n, cb) => {
-      const objects = range(n).map(() => {
-        const obj = space.db.add(Obj.make(DiagramType, {
-          name: faker.commerce.productName(),
-          canvas: Ref.make(Obj.make(CanvasType, {
-            content: {}
-          }))
-        }));
-        return obj;
-      });
-      cb?.(objects);
-      return objects;
-    }
-  ],
-  // TODO(burdon): Create unit tests.
-  [
-    SheetType.typename,
-    async (space, n, cb) => {
-      const objects = range(n).map(() => {
-        const cells = {};
-        const year = (/* @__PURE__ */ new Date()).getFullYear();
-        const cols = 4;
-        const rows = 16;
-        for (let col = 1; col <= cols; col++) {
-          for (let row = 1; row <= rows; row++) {
-            const cell = addressToA1Notation({
-              col,
-              row
-            });
-            if (row === 1) {
-              cells[cell] = {
-                value: `${year} Q${col}`
-              };
-            } else if (row === rows) {
-              const from = addressToA1Notation({
-                col,
-                row: 2
-              });
-              const to = addressToA1Notation({
-                col,
-                row: rows - 1
-              });
-              cells[cell] = {
-                value: `=SUM(${from}:${to})`
-              };
-            } else if (row > 2 && row < rows - 1) {
-              cells[cell] = {
-                value: Math.floor(Math.random() * 1e4)
-              };
-            }
-          }
-        }
-        return space.db.add(createSheet({
-          name: faker.commerce.productName(),
-          cells
-        }));
-      });
-      cb?.(objects);
-      return objects;
-    }
-  ],
-  [
-    ComputeGraph.typename,
-    async (space, n, cb) => {
-      const objects = range(n, () => {
-        const model = ComputeGraphModel.create();
-        model.builder.createNode({
-          id: "gpt-INPUT",
-          type: NODE_INPUT
-        }).createNode({
-          id: "gpt-GPT",
-          type: "gpt"
-        }).createNode({
-          id: "gpt-QUEUE_ID",
-          type: "constant",
-          value: new DXN(DXN.kind.QUEUE, [
-            "data",
-            space.id,
-            Key.ObjectId.random()
-          ]).toString()
-        }).createNode({
-          id: "gpt-APPEND",
-          type: "append"
-        }).createNode({
-          id: "gpt-OUTPUT",
-          type: NODE_OUTPUT
-        }).createEdge({
-          node: "gpt-INPUT",
-          property: "prompt"
-        }, {
-          node: "gpt-GPT",
-          property: "prompt"
-        }).createEdge({
-          node: "gpt-GPT",
-          property: "text"
-        }, {
-          node: "gpt-OUTPUT",
-          property: "text"
-        }).createEdge({
-          node: "gpt-QUEUE_ID",
-          property: DEFAULT_OUTPUT
-        }, {
-          node: "gpt-APPEND",
-          property: "id"
-        }).createEdge({
-          node: "gpt-GPT",
-          property: "messages"
-        }, {
-          node: "gpt-APPEND",
-          property: "items"
-        }).createEdge({
-          node: "gpt-QUEUE_ID",
-          property: DEFAULT_OUTPUT
-        }, {
-          node: "gpt-OUTPUT",
-          property: "queue"
-        });
-        return space.db.add(model.root);
-      });
-      cb?.(objects);
-      return objects;
-    }
-  ]
-]);
-
-// packages/plugins/plugin-debug/src/components/SpaceGenerator/SchemaTable.tsx
-import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
-import React from "react";
-import { IconButton } from "@dxos/react-ui";
-var SchemaTable = ({ types, objects = {}, label, onClick }) => {
-  var _effect = _useSignals();
-  try {
-    return /* @__PURE__ */ React.createElement("div", {
-      className: "grid grid-cols-[1fr_80px_40px] gap-1 overflow-none"
-    }, /* @__PURE__ */ React.createElement("h2", {
-      className: "p-2"
-    }, label), types.map((type) => /* @__PURE__ */ React.createElement("div", {
-      key: type.typename,
-      className: "grid grid-cols-subgrid col-span-3 items-center"
-    }, /* @__PURE__ */ React.createElement("div", {
-      className: "px-2 text-sm font-mono text-subdued"
-    }, type.typename), /* @__PURE__ */ React.createElement("div", {
-      className: "px-2 text-right font-mono"
-    }, objects[type.typename] ?? 0), /* @__PURE__ */ React.createElement(IconButton, {
-      variant: "ghost",
-      icon: "ph--plus--regular",
-      iconOnly: true,
-      label: "Create data",
-      onClick: () => onClick(type.typename)
-    }))));
-  } finally {
-    _effect.f();
-  }
-};
-
-// packages/plugins/plugin-debug/src/components/SpaceGenerator/presets.ts
-import { Schema, SchemaAST } from "effect";
-import { NODE_INPUT as NODE_INPUT2 } from "@dxos/conductor";
-import { DXN as DXN2, Key as Key2, Obj as Obj2, Ref as Ref2, Type } from "@dxos/echo";
-import { FunctionTrigger, TriggerKind, EmailTriggerOutput } from "@dxos/functions";
-import { invariant } from "@dxos/invariant";
-import { Filter as Filter2 } from "@dxos/react-client/echo";
-import { createAppend, createChat, createComputeGraph, createConstant, createFunction, createGpt, createQueue, createSurface, createRandom, createTemplate, createText, createTrigger } from "@dxos/react-ui-canvas-compute";
-import { CanvasBoardType, CanvasGraphModel, pointMultiply, pointsToRect, rectToPoints } from "@dxos/react-ui-canvas-editor";
-import { TableType as TableType2 } from "@dxos/react-ui-table";
-import { range as range2 } from "@dxos/util";
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/plugin-debug/src/components/SpaceGenerator/presets.ts";
-var PresetName = /* @__PURE__ */ function(PresetName2) {
-  PresetName2["EMAIL_TABLE"] = "email-table";
-  PresetName2["GPT_QUEUE"] = "webhook-gpt-queue";
-  PresetName2["CHAT_GPT"] = "chat-gpt-text";
-  PresetName2["EMAIL_WITH_SUMMARY"] = "email-gptSummary-table";
-  PresetName2["OBJECT_CHANGE_QUEUE"] = "objectChange-queue";
-  PresetName2["FOREX_FUNCTION_CALL"] = "forex-function-call";
-  PresetName2["TIMER_TICK_QUEUE"] = "timerTick-queue";
-  PresetName2["DISCORD_MESSAGES"] = "discord-messages";
-  PresetName2["KANBAN_QUEUE"] = "kanban-queue";
-  return PresetName2;
-}({});
-var generator2 = () => ({
-  schemas: [
-    CanvasBoardType,
-    FunctionTrigger
-  ],
-  types: Object.values(PresetName).map((name) => ({
-    typename: name
-  })),
-  items: [
-    [
-      "webhook-gpt-queue",
-      async (space, n, cb) => {
-        const objects = range2(n, () => {
-          const canvasModel = CanvasGraphModel.create();
-          let functionTrigger;
-          canvasModel.builder.call((builder) => {
-            const gpt = canvasModel.createNode(createGpt(position({
-              x: 0,
-              y: -14
-            })));
-            const triggerShape = createTrigger({
-              spaceId: space.id,
-              triggerKind: TriggerKind.Webhook,
-              ...position({
-                x: -18,
-                y: -2
-              })
-            });
-            const trigger = canvasModel.createNode(triggerShape);
-            const text = canvasModel.createNode(createText(position({
-              x: 19,
-              y: 3,
-              width: 10,
-              height: 10
-            })));
-            const { queueId } = setupQueue(space, canvasModel);
-            const append = canvasModel.createNode(createAppend(position({
-              x: 10,
-              y: 6
-            })));
-            builder.createEdge({
-              source: trigger.id,
-              target: gpt.id,
-              input: "prompt",
-              output: "bodyText"
-            }).createEdge({
-              source: gpt.id,
-              target: text.id,
-              output: "text"
-            }).createEdge({
-              source: queueId.id,
-              target: append.id,
-              input: "id"
-            }).createEdge({
-              source: gpt.id,
-              target: append.id,
-              output: "messages",
-              input: "items"
-            });
-            functionTrigger = triggerShape.functionTrigger.target;
-          });
-          const computeModel = createComputeGraph(canvasModel);
-          attachTrigger(functionTrigger, computeModel);
-          return addToSpace("webhook-gpt-queue", space, canvasModel, computeModel);
-        });
-        cb?.(objects);
-        return objects;
-      }
-    ],
-    [
-      "objectChange-queue",
-      async (space, n, cb) => {
-        const objects = range2(n, () => {
-          const { canvasModel, computeModel } = createQueueSinkPreset(space, TriggerKind.Subscription, (triggerSpec) => triggerSpec.filter = {
-            type: "dxn:type:dxos.org/type/Chess"
-          }, "type");
-          return addToSpace("objectChange-queue", space, canvasModel, computeModel);
-        });
-        cb?.(objects);
-        return objects;
-      }
-    ],
-    [
-      "timerTick-queue",
-      async (space, n, cb) => {
-        const objects = range2(n, () => {
-          const { canvasModel, computeModel } = createQueueSinkPreset(space, TriggerKind.Timer, (triggerSpec) => triggerSpec.cron = "*/5 * * * * *", "result");
-          return addToSpace("timerTick-queue", space, canvasModel, computeModel);
-        });
-        cb?.(objects);
-        return objects;
-      }
-    ],
-    [
-      "email-table",
-      async (space, n, cb) => {
-        const objects = range2(n, () => {
-          const canvasModel = CanvasGraphModel.create();
-          const results = space.db.query(Filter2.type(TableType2)).runSync();
-          const emailTable = results.find((r) => r.object?.view?.target?.query?.typename?.endsWith("Email"));
-          invariant(emailTable, "Email table not found.", {
-            F: __dxlog_file,
-            L: 136,
-            S: void 0,
-            A: [
-              "emailTable",
-              "'Email table not found.'"
-            ]
-          });
-          const template = canvasModel.createNode(createTemplate({
-            valueType: "object",
-            ...rawPosition({
-              centerX: -80,
-              centerY: -64,
-              width: 320,
-              height: 320
-            })
-          }));
-          const templateContent = [
-            "{"
-          ];
-          let functionTrigger;
-          canvasModel.builder.call((builder) => {
-            const triggerShape = createTrigger({
-              spaceId: space.id,
-              triggerKind: TriggerKind.Email,
-              ...position({
-                x: -18,
-                y: -2
-              })
-            });
-            const trigger = canvasModel.createNode(triggerShape);
-            const tableId = canvasModel.createNode(createConstant({
-              value: DXN2.fromLocalObjectId(emailTable.id).toString(),
-              ...position({
-                x: -18,
-                y: 5,
-                width: 8,
-                height: 6
-              })
-            }));
-            const appendToTable = canvasModel.createNode(createAppend(position({
-              x: 10,
-              y: 6
-            })));
-            const properties = SchemaAST.getPropertySignatures(EmailTriggerOutput.ast);
-            for (let i = 0; i < properties.length; i++) {
-              const propName = properties[i].name.toString();
-              builder.createEdge({
-                source: trigger.id,
-                target: template.id,
-                input: propName,
-                output: propName
-              });
-              templateContent.push(`  "${propName}": "{{${propName}}}"` + (i === properties.length - 1 ? "" : ","));
-            }
-            templateContent.push("}");
-            builder.createEdge({
-              source: tableId.id,
-              target: appendToTable.id,
-              input: "id"
-            }).createEdge({
-              source: template.id,
-              target: appendToTable.id,
-              input: "items"
-            });
-            functionTrigger = triggerShape.functionTrigger.target;
-          });
-          const computeModel = createComputeGraph(canvasModel);
-          const templateComputeNode = computeModel.nodes.find((n2) => n2.id === template.node);
-          invariant(templateComputeNode, "Template compute node was not created.", {
-            F: __dxlog_file,
-            L: 182,
-            S: void 0,
-            A: [
-              "templateComputeNode",
-              "'Template compute node was not created.'"
-            ]
-          });
-          templateComputeNode.value = templateContent.join("\n");
-          templateComputeNode.inputSchema = Type.toJsonSchema(EmailTriggerOutput);
-          attachTrigger(functionTrigger, computeModel);
-          return addToSpace("email-table", space, canvasModel, computeModel);
-        });
-        cb?.(objects);
-        return objects;
-      }
-    ],
-    [
-      "chat-gpt-text",
-      async (space, n, cb) => {
-        const objects = range2(n, () => {
-          const canvasModel = CanvasGraphModel.create();
-          canvasModel.builder.call((builder) => {
-            const gpt = canvasModel.createNode(createGpt(position({
-              x: 0,
-              y: -14
-            })));
-            const chat = canvasModel.createNode(createChat(position({
-              x: -18,
-              y: -2
-            })));
-            const text = canvasModel.createNode(createText(position({
-              x: 19,
-              y: 3,
-              width: 10,
-              height: 10
-            })));
-            const { queueId } = setupQueue(space, canvasModel);
-            const append = canvasModel.createNode(createAppend(position({
-              x: 10,
-              y: 6
-            })));
-            builder.createEdge({
-              source: chat.id,
-              target: gpt.id,
-              input: "prompt"
-            }).createEdge({
-              source: gpt.id,
-              target: text.id,
-              output: "text"
-            }).createEdge({
-              source: queueId.id,
-              target: append.id,
-              input: "id"
-            }).createEdge({
-              source: gpt.id,
-              target: append.id,
-              output: "messages",
-              input: "items"
-            });
-          });
-          const computeModel = createComputeGraph(canvasModel);
-          return addToSpace("chat-gpt-text", space, canvasModel, computeModel);
-        });
-        cb?.(objects);
-        return objects;
-      }
-    ],
-    [
-      "email-gptSummary-table",
-      async (space, n, cb) => {
-        const objects = range2(n, () => {
-          const canvasModel = CanvasGraphModel.create();
-          const results = space.db.query(Filter2.type(TableType2)).runSync();
-          const emailTable = results.find((r) => r.object?.view?.target?.query?.typename?.endsWith("Email"));
-          invariant(emailTable, "Email table not found.", {
-            F: __dxlog_file,
-            L: 233,
-            S: void 0,
-            A: [
-              "emailTable",
-              "'Email table not found.'"
-            ]
-          });
-          const template = canvasModel.createNode(createTemplate({
-            valueType: "object",
-            ...rawPosition({
-              centerX: 192,
-              centerY: -176,
-              width: 320,
-              height: 320
-            })
-          }));
-          const templateContent = [
-            "{"
-          ];
-          let functionTrigger;
-          canvasModel.builder.call((builder) => {
-            const gpt = canvasModel.createNode(createGpt(rawPosition({
-              centerX: -400,
-              centerY: -112,
-              width: 256,
-              height: 202
-            })));
-            const systemPrompt = canvasModel.createNode(createConstant({
-              value: "use one word to describe content category. don't write anything else",
-              ...rawPosition({
-                centerX: -800,
-                centerY: -160,
-                width: 192,
-                height: 128
-              })
-            }));
-            const triggerShape = createTrigger({
-              spaceId: space.id,
-              triggerKind: TriggerKind.Email,
-              ...rawPosition({
-                centerX: -736,
-                centerY: -384,
-                width: 182,
-                height: 192
-              })
-            });
-            const trigger = canvasModel.createNode(triggerShape);
-            const { queueId } = setupQueue(space, canvasModel, {
-              idPosition: {
-                centerX: -720,
-                centerY: 224,
-                width: 192,
-                height: 256
-              },
-              queuePosition: {
-                centerX: -144,
-                centerY: 416,
-                width: 320,
-                height: 448
-              }
-            });
-            const appendToQueue = canvasModel.createNode(createAppend(rawPosition({
-              centerX: -80,
-              centerY: 96,
-              width: 122,
-              height: 128
-            })));
-            const tableId = canvasModel.createNode(createConstant({
-              value: DXN2.fromLocalObjectId(emailTable.id).toString(),
-              ...rawPosition({
-                centerX: -112,
-                centerY: -544,
-                width: 192,
-                height: 256
-              })
-            }));
-            const appendToTable = canvasModel.createNode(createAppend(rawPosition({
-              centerX: 560,
-              centerY: -416,
-              width: 128,
-              height: 122
-            })));
-            templateContent.push('  "category": "{{text}}",');
-            builder.createEdge({
-              source: gpt.id,
-              target: template.id,
-              input: "text",
-              output: "text"
-            });
-            const properties = SchemaAST.getPropertySignatures(EmailTriggerOutput.ast);
-            for (let i = 0; i < properties.length; i++) {
-              const propName = properties[i].name.toString();
-              builder.createEdge({
-                source: trigger.id,
-                target: template.id,
-                input: propName,
-                output: propName
-              });
-              templateContent.push(`  "${propName}": "{{${propName}}}"` + (i === properties.length - 1 ? "" : ","));
-            }
-            templateContent.push("}");
-            builder.createEdge({
-              source: tableId.id,
-              target: appendToTable.id,
-              input: "id"
-            }).createEdge({
-              source: queueId.id,
-              target: appendToQueue.id,
-              input: "id"
-            }).createEdge({
-              source: gpt.id,
-              target: appendToQueue.id,
-              output: "messages",
-              input: "items"
-            }).createEdge({
-              source: systemPrompt.id,
-              target: gpt.id,
-              input: "systemPrompt"
-            }).createEdge({
-              source: trigger.id,
-              target: gpt.id,
-              input: "prompt",
-              output: "body"
-            }).createEdge({
-              source: template.id,
-              target: appendToTable.id,
-              input: "items"
-            });
-            functionTrigger = triggerShape.functionTrigger.target;
-          });
-          const computeModel = createComputeGraph(canvasModel);
-          const templateComputeNode = computeModel.nodes.find((n2) => n2.id === template.node);
-          invariant(templateComputeNode, "Template compute node was not created.", {
-            F: __dxlog_file,
-            L: 305,
-            S: void 0,
-            A: [
-              "templateComputeNode",
-              "'Template compute node was not created.'"
-            ]
-          });
-          templateComputeNode.value = templateContent.join("\n");
-          const extendedSchema = Schema.extend(EmailTriggerOutput, Schema.Struct({
-            text: Schema.String
-          }));
-          templateComputeNode.inputSchema = Type.toJsonSchema(extendedSchema);
-          attachTrigger(functionTrigger, computeModel);
-          return addToSpace("email-gptSummary-table", space, canvasModel, computeModel);
-        });
-        cb?.(objects);
-        return objects;
-      }
-    ],
-    [
-      "forex-function-call",
-      async (space, n, cb) => {
-        const objects = range2(n, () => {
-          const canvasModel = CanvasGraphModel.create();
-          canvasModel.builder.call((builder) => {
-            const sourceCurrency = canvasModel.createNode(createConstant({
-              value: "USD",
-              ...position({
-                x: -10,
-                y: -5
-              })
-            }));
-            const targetCurrency = canvasModel.createNode(createConstant({
-              value: "EUR",
-              ...position({
-                x: -10,
-                y: 5
-              })
-            }));
-            const converter = canvasModel.createNode(createFunction(position({
-              x: 0,
-              y: 0
-            })));
-            const view = canvasModel.createNode(createSurface(position({
-              x: 12,
-              y: 0
-            })));
-            builder.createEdge({
-              source: sourceCurrency.id,
-              target: converter.id,
-              input: "from"
-            }).createEdge({
-              source: targetCurrency.id,
-              target: converter.id,
-              input: "to"
-            }).createEdge({
-              source: converter.id,
-              target: view.id,
-              output: "rate"
-            });
-          });
-          const computeModel = createComputeGraph(canvasModel);
-          return addToSpace("forex-function-call", space, canvasModel, computeModel);
-        });
-        cb?.(objects);
-        return objects;
-      }
-    ],
-    [
-      "discord-messages",
-      async (space, n, cb) => {
-        const objects = range2(n, () => {
-          const canvasModel = CanvasGraphModel.create();
-          let functionTrigger;
-          canvasModel.builder.call((builder) => {
-            const triggerShape = createTrigger({
-              spaceId: space.id,
-              triggerKind: TriggerKind.Timer,
-              ...position({
-                x: -10,
-                y: -5
-              })
-            });
-            const trigger = canvasModel.createNode(triggerShape);
-            const channelId = canvasModel.createNode(createConstant({
-              value: "1088569858767212554",
-              ...position({
-                x: -10,
-                y: 0
-              })
-            }));
-            const queueId = canvasModel.createNode(createConstant({
-              value: new DXN2(DXN2.kind.QUEUE, [
-                "data",
-                space.id,
-                Key2.ObjectId.random()
-              ]).toString(),
-              ...position({
-                x: -10,
-                y: 5
-              })
-            }));
-            const converter = canvasModel.createNode(createFunction(position({
-              x: 0,
-              y: 0
-            })));
-            const view = canvasModel.createNode(createText(position({
-              x: 12,
-              y: 0
-            })));
-            const queue = canvasModel.createNode(createQueue(position({
-              x: 0,
-              y: 12
-            })));
-            builder.createEdge({
-              source: trigger.id,
-              target: converter.id,
-              input: "tick"
-            }).createEdge({
-              source: channelId.id,
-              target: converter.id,
-              input: "channelId"
-            }).createEdge({
-              source: queueId.id,
-              target: converter.id,
-              input: "queueId"
-            }).createEdge({
-              source: converter.id,
-              target: view.id,
-              output: "newMessages"
-            }).createEdge({
-              source: queueId.id,
-              target: queue.id,
-              input: "input"
-            });
-            functionTrigger = triggerShape.functionTrigger.target;
-          });
-          const computeModel = createComputeGraph(canvasModel);
-          attachTrigger(functionTrigger, computeModel);
-          return addToSpace("discord-messages", space, canvasModel, computeModel);
-        });
-        cb?.(objects);
-        return objects;
-      }
-    ],
-    [
-      "kanban-queue",
-      async (space, n, cb) => {
-        const objects = range2(n, () => {
-          const canvasModel = CanvasGraphModel.create();
-          const results = space.db.query(Filter2.type(TableType2)).runSync();
-          const messages = results.find((r) => r.object?.view?.target?.query?.typename?.endsWith("Message"));
-          invariant(messages, "Table not found.", {
-            F: __dxlog_file,
-            L: 411,
-            S: void 0,
-            A: [
-              "messages",
-              "'Table not found.'"
-            ]
-          });
-          let functionTrigger;
-          canvasModel.builder.call((builder) => {
-            const triggerShape = createTrigger({
-              spaceId: space.id,
-              triggerKind: TriggerKind.Queue,
-              ...position({
-                x: -10,
-                y: -5
-              })
-            });
-            const trigger = canvasModel.createNode(triggerShape);
-            const tableId = canvasModel.createNode(createConstant({
-              value: DXN2.fromLocalObjectId(messages.id).toString(),
-              ...position({
-                x: -10,
-                y: 5
-              })
-            }));
-            const appendToTable = canvasModel.createNode(createAppend(position({
-              x: 10,
-              y: 0
-            })));
-            builder.createEdge({
-              source: tableId.id,
-              target: appendToTable.id,
-              input: "id"
-            }).createEdge({
-              source: trigger.id,
-              target: appendToTable.id,
-              input: "items",
-              output: "item"
-            });
-            functionTrigger = triggerShape.functionTrigger.target;
-          });
-          const computeModel = createComputeGraph(canvasModel);
-          attachTrigger(functionTrigger, computeModel);
-          return addToSpace("kanban-queue", space, canvasModel, computeModel);
-        });
-        cb?.(objects);
-        return objects;
-      }
-    ]
-  ]
-});
-var createQueueSinkPreset = (space, triggerKind, initSpec, triggerOutputName) => {
-  const canvasModel = CanvasGraphModel.create();
-  const template = canvasModel.createNode(createTemplate({
-    valueType: "object",
-    ...rawPosition({
-      centerX: -64,
-      centerY: -79,
-      width: 320,
-      height: 320
-    })
-  }));
-  let functionTrigger;
-  canvasModel.builder.call((builder) => {
-    const triggerShape = createTrigger({
-      spaceId: space.id,
-      triggerKind,
-      ...rawPosition({
-        centerX: -578,
-        centerY: -187,
-        height: 320,
-        width: 320
-      })
-    });
-    const trigger = canvasModel.createNode(triggerShape);
-    const { queueId } = setupQueue(space, canvasModel, {
-      queuePosition: {
-        centerX: -80,
-        centerY: 378,
-        width: 320,
-        height: 448
-      }
-    });
-    const append = canvasModel.createNode(createAppend(rawPosition({
-      centerX: 320,
-      centerY: 192,
-      width: 128,
-      height: 122
-    })));
-    const random = canvasModel.createNode(createRandom(rawPosition({
-      centerX: -509,
-      centerY: -30,
-      width: 64,
-      height: 64
-    })));
-    builder.createEdge({
-      source: queueId.id,
-      target: append.id,
-      input: "id"
-    }).createEdge({
-      source: template.id,
-      target: append.id,
-      input: "items"
-    }).createEdge({
-      source: trigger.id,
-      target: template.id,
-      output: triggerOutputName,
-      input: "type"
-    }).createEdge({
-      source: random.id,
-      target: template.id,
-      input: "changeId"
-    });
-    functionTrigger = triggerShape.functionTrigger.target;
-    const triggerSpec = functionTrigger.spec;
-    invariant(triggerSpec && triggerSpec.kind === triggerKind, "No trigger spec.", {
-      F: __dxlog_file,
-      L: 494,
-      S: void 0,
-      A: [
-        "triggerSpec && triggerSpec.kind === triggerKind",
-        "'No trigger spec.'"
-      ]
-    });
-    initSpec(triggerSpec);
-  });
-  const computeModel = createComputeGraph(canvasModel);
-  const templateComputeNode = computeModel.nodes.find((n) => n.id === template.node);
-  invariant(templateComputeNode, "Template compute node was not created.", {
-    F: __dxlog_file,
-    L: 501,
-    S: void 0,
-    A: [
-      "templateComputeNode",
-      "'Template compute node was not created.'"
-    ]
-  });
-  templateComputeNode.value = [
-    "{",
-    '  "@type": "{{type}}",',
-    '  "id": "@{{changeId}}"',
-    "}"
-  ].join("\n");
-  templateComputeNode.inputSchema = Type.toJsonSchema(Schema.Struct({
-    type: Schema.String,
-    changeId: Schema.String
-  }));
-  attachTrigger(functionTrigger, computeModel);
-  return {
-    canvasModel,
-    computeModel
-  };
-};
-var addToSpace = (name, space, canvas, compute) => {
-  return space.db.add(Obj2.make(CanvasBoardType, {
-    name,
-    computeGraph: Ref2.make(compute.root),
-    layout: canvas.graph
-  }));
-};
-var setupQueue = (space, canvasModel, args) => {
-  const queueId = canvasModel.createNode(createConstant({
-    value: new DXN2(DXN2.kind.QUEUE, [
-      "data",
-      space.id,
-      Key2.ObjectId.random()
-    ]).toString(),
-    ...args?.idPosition ? rawPosition(args.idPosition) : position({
-      x: -18,
-      y: 5,
-      width: 8,
-      height: 6
-    })
-  }));
-  const queue = canvasModel.createNode(createQueue(args?.queuePosition ? rawPosition(args.queuePosition) : position({
-    x: -3,
-    y: 3,
-    width: 14,
-    height: 10
-  })));
-  canvasModel.createEdge({
-    source: queueId.id,
-    target: queue.id
-  });
-  return {
-    queue,
-    queueId
-  };
-};
-var attachTrigger = (functionTrigger, computeModel) => {
-  invariant(functionTrigger, void 0, {
-    F: __dxlog_file,
-    L: 540,
-    S: void 0,
-    A: [
-      "functionTrigger",
-      ""
-    ]
-  });
-  functionTrigger.function = Ref2.make(computeModel.root);
-  const inputNode = computeModel.nodes.find((node) => node.type === NODE_INPUT2);
-  functionTrigger.inputNodeId = inputNode.id;
-};
-var rawPosition = (args) => {
-  return {
-    center: {
-      x: args.centerX,
-      y: args.centerY
-    },
-    size: {
-      width: args.width,
-      height: args.height
-    }
-  };
-};
-var position = (rect) => {
-  const snap = 32;
-  const [center, size] = rectToPoints({
-    width: 0,
-    height: 0,
-    ...rect
-  });
-  const { x, y, width, height } = pointsToRect([
-    pointMultiply(center, snap),
-    pointMultiply(size, snap)
-  ]);
-  if (width && height) {
-    return {
-      center: {
-        x,
-        y
-      },
-      size: width && height ? {
-        width,
-        height
-      } : void 0
-    };
-  } else {
-    return {
-      center: {
-        x,
-        y
-      }
-    };
-  }
-};
-
-// packages/plugins/plugin-debug/src/components/SpaceGenerator/SpaceGenerator.tsx
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/plugins/plugin-debug/src/components/SpaceGenerator/SpaceGenerator.tsx";
-var SpaceGenerator = ({ space, onCreateObjects }) => {
-  var _effect = _useSignals2();
-  try {
-    const { dispatchPromise: dispatch } = useIntentDispatcher();
-    const client = useClient();
-    const staticTypes = [
-      DocumentType2,
-      DiagramType2,
-      SheetType2,
-      ComputeGraph2
-    ];
-    const mutableTypes = [
-      DataType2.Organization,
-      DataType2.Project,
-      DataType2.Person,
-      DataType2.Message
-    ];
-    const [count, setCount] = useState(1);
-    const [info, setInfo] = useState({});
-    const presets = useMemo(() => generator2(), []);
-    const typeMap = useMemo(() => {
-      client.addTypes([
-        ...staticTypes,
-        ...presets.schemas
-      ]);
-      const mutableGenerators = new Map(mutableTypes.map((type) => [
-        type.typename,
-        createGenerator(type)
-      ]));
-      return new Map([
-        ...staticGenerators,
-        ...presets.items,
-        ...mutableGenerators
-      ]);
-    }, [
-      client,
-      mutableTypes
-    ]);
-    const updateInfo = async () => {
-      const echoSchema = await space.db.schemaRegistry.query().run();
-      const staticSchema = space.db.graph.schemaRegistry.schemas;
-      const { objects } = await space.db.query(Filter3.everything()).run();
-      const objectMap = sortKeys(objects.reduce((map, obj) => {
-        const type = getTypename(obj);
-        if (type) {
-          const count2 = map[type] ?? 0;
-          map[type] = count2 + 1;
-        }
-        return map;
-      }, {}));
-      setInfo({
-        schema: {
-          static: staticSchema.length,
-          mutable: echoSchema.length
-        },
-        objects: objectMap
-      });
-    };
-    useAsyncEffect(updateInfo, [
-      space
-    ]);
-    const handleCreateData = useCallback(async (typename) => {
-      const constructor = typeMap.get(typename);
-      if (constructor) {
-        await constructor(space, count, onCreateObjects);
-        await updateInfo();
-      }
-    }, [
-      typeMap,
-      count
-    ]);
-    const handleLoadTables = useCallback(async () => {
-      const input = document.createElement("input");
-      input.type = "file";
-      input.accept = ".json";
-      input.onchange = async (e) => {
-        const file = e.target.files?.[0];
-        if (!file) {
-          return;
-        }
-        try {
-          const content = await file.text();
-          const data = JSON.parse(content);
-          const schemas = await space.db.schemaRegistry.register(data.schemas.map(Type2.toEffectSchema));
-          await Promise.all(schemas.map(async (schema) => {
-            const parts = schema.typename.split("/");
-            const name = parts[parts.length - 1];
-            const table = Obj3.make(TableType3, {
-              name,
-              threads: []
-            });
-            await initializeTable({
-              client,
-              space,
-              table,
-              typename: schema.typename
-            });
-            await dispatch(createIntent(SpaceAction.AddObject, {
-              target: space,
-              object: table
-            }));
-            return table;
-          }));
-          await Promise.all(data.objects.map(async ({ id, "@type": typename, ...fields }) => {
-            const schema = schemas.find((s) => `dxn:type:${s.typename}:${s.version}` === typename);
-            if (!schema) {
-              log.warn("Missing schema for object", {
-                id,
-                typename
-              }, {
-                F: __dxlog_file2,
-                L: 125,
-                S: void 0,
-                C: (f, a) => f(...a)
-              });
-              return;
-            }
-            const object = Obj3.make(schema, fields);
-            space.db.add(object);
-            return object;
-          }));
-        } catch (err) {
-          log.catch(err, void 0, {
-            F: __dxlog_file2,
-            L: 134,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-        }
-      };
-      input.click();
-    }, []);
-    return /* @__PURE__ */ React2.createElement("div", {
-      role: "none",
-      className: "flex flex-col grow overflow-hidden"
-    }, /* @__PURE__ */ React2.createElement(Toolbar.Root, {
-      classNames: "border-be border-subduedSeparator"
-    }, /* @__PURE__ */ React2.createElement(IconButton2, {
-      icon: "ph--arrow-clockwise--regular",
-      iconOnly: true,
-      label: "Refresh",
-      onClick: updateInfo
-    }), /* @__PURE__ */ React2.createElement(IconButton2, {
-      icon: "ph--file-arrow-up--regular",
-      iconOnly: true,
-      label: "Load tables from JSON",
-      onClick: handleLoadTables
-    }), /* @__PURE__ */ React2.createElement(Toolbar.Separator, {
-      variant: "gap"
-    }), /* @__PURE__ */ React2.createElement(Input.Root, null, /* @__PURE__ */ React2.createElement(Input.TextInput, {
-      type: "number",
-      min: 1,
-      max: 100,
-      placeholder: "Count",
-      classNames: "!w-[4rem] !text-right",
-      size: 8,
-      value: count,
-      onChange: (ev) => setCount(parseInt(ev.target.value))
-    }))), /* @__PURE__ */ React2.createElement("div", {
-      className: "flex flex-col overflow-y-auto divide-y divide-separator"
-    }, /* @__PURE__ */ React2.createElement(SchemaTable, {
-      types: staticTypes,
-      objects: info.objects,
-      label: "Static Types",
-      onClick: handleCreateData
-    }), /* @__PURE__ */ React2.createElement(SchemaTable, {
-      types: mutableTypes,
-      objects: info.objects,
-      label: "Mutable Types",
-      onClick: handleCreateData
-    }), /* @__PURE__ */ React2.createElement(SchemaTable, {
-      types: presets.types,
-      objects: info.objects,
-      label: "Presets",
-      onClick: handleCreateData
-    }), /* @__PURE__ */ React2.createElement("div", null, /* @__PURE__ */ React2.createElement(SyntaxHighlighter, {
-      classNames: "flex text-xs",
-      language: "json"
-    }, JSON.stringify({
-      space,
-      ...info
-    }, jsonKeyReplacer({
-      truncate: true
-    }), 2)))));
-  } finally {
-    _effect.f();
-  }
-};
-
-// packages/plugins/plugin-debug/src/components/SpaceGenerator/index.ts
-var SpaceGenerator_default = SpaceGenerator;
-export {
-  SpaceGenerator_default as default
-};
-//# sourceMappingURL=SpaceGenerator-VB6IB2LL.mjs.map