@dxos/plugin-debug 0.8.3 → 0.8.4-main.f9ba587

package/dist/lib/node-esm/SpaceGenerator-MJR725EE.mjs

@@ -0,0 +1,1240 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// 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";
+
+// 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;
+    }
+  ]
+]);
+
+// 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();
+  }
+};
+
+// 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 = "/__w/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
+      }
+    };
+  }
+};
+
+// src/components/SpaceGenerator/SpaceGenerator.tsx
+var __dxlog_file2 = "/__w/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();
+  }
+};
+
+// src/components/SpaceGenerator/index.ts
+var SpaceGenerator_default = SpaceGenerator;
+export {
+  SpaceGenerator_default as default
+};
+//# sourceMappingURL=SpaceGenerator-MJR725EE.mjs.map