@dxos/plugin-script 0.6.8-main.046e6cf

package/dist/lib/node/chunk-LWUBFTPA.cjs

@@ -0,0 +1,253 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_LWUBFTPA_exports = {};
+__export(chunk_LWUBFTPA_exports, {
+  HeaderCodec: () => HeaderCodec,
+  codec: () => codec,
+  getUserFunctionUrlInMetadata: () => getUserFunctionUrlInMetadata,
+  matchServiceCredential: () => matchServiceCredential,
+  publicKeyToDid: () => publicKeyToDid,
+  setUserFunctionUrlInMetadata: () => setUserFunctionUrlInMetadata,
+  uploadWorkerFunction: () => uploadWorkerFunction
+});
+module.exports = __toCommonJS(chunk_LWUBFTPA_exports);
+var import_keys = require("@dxos/keys");
+var import_async = require("@dxos/async");
+var import_invariant = require("@dxos/invariant");
+var import_log = require("@dxos/log");
+var ENCODING = "base64";
+var HeaderCodec = class {
+  constructor(_keyCodec) {
+    this._keyCodec = _keyCodec;
+  }
+  encode(obj) {
+    const objectToEncode = this._prepareForEncoding(obj);
+    const encoded = Buffer.from(JSON.stringify(objectToEncode));
+    return encoded.toString(ENCODING);
+  }
+  decode(buffer) {
+    const json = JSON.parse(Buffer.from(buffer, ENCODING).toString());
+    return this._decodeRecursive(json);
+  }
+  _decodeRecursive(obj) {
+    return this._recurse(obj, (value) => {
+      if (isEncodedBytes(value)) {
+        return decodeBytes(value.__b);
+      }
+      if (isEncodedKey(value)) {
+        return this._keyCodec.decode(value);
+      }
+      if (isEncodedDate(value)) {
+        return decodeDate(value);
+      }
+      return null;
+    });
+  }
+  _prepareForEncoding(obj) {
+    return this._recurse(obj, (value) => {
+      if (value instanceof Uint8Array) {
+        return {
+          __b: encodeBytes(value)
+        };
+      }
+      if (this._keyCodec.isKey(value)) {
+        return this._keyCodec.encode(value);
+      }
+      if (value instanceof Date) {
+        return encodeDate(value);
+      }
+      return null;
+    });
+  }
+  _recurse(obj, handler) {
+    if (typeof obj !== "object") {
+      return obj;
+    }
+    const handled = handler(obj);
+    if (handled != null) {
+      return handled;
+    }
+    if (Array.isArray(obj)) {
+      const result2 = [];
+      for (const elem of obj) {
+        result2.push(this._recurse(elem, handler));
+      }
+      return result2;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = this._recurse(value, handler);
+    }
+    return result;
+  }
+};
+var isEncodedKey = (obj) => "__k" in obj && typeof obj.__k === "string";
+var isEncodedBytes = (obj) => "__b" in obj && typeof obj.__b === "string";
+var isEncodedDate = (obj) => "__t" in obj && typeof obj.__t === "number";
+var encodeDate = (date) => ({
+  __t: date.getTime()
+});
+var decodeDate = (timestamp) => new Date(timestamp.__t);
+var encodeBytes = (bytes) => Buffer.from(bytes).toString(ENCODING);
+var decodeBytes = (bytes) => Buffer.from(bytes, ENCODING);
+var codec = new HeaderCodec({
+  isKey: (value) => value instanceof import_keys.PublicKey,
+  encode: (key) => ({
+    __k: key.toHex()
+  }),
+  decode: (value) => import_keys.PublicKey.fromHex(value.__k)
+});
+var matchServiceCredential = (capabilities = []) => (credential) => {
+  if (credential.subject.assertion["@type"] !== "dxos.halo.credentials.ServiceAccess") {
+    return false;
+  }
+  const { capabilities: credentialCapabilities } = credential.subject.assertion;
+  return capabilities.every((capability) => credentialCapabilities.includes(capability));
+};
+var publicKeyToDid = (key) => {
+  return `did:key:${key.toHex()}`;
+};
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/plugins/experimental/plugin-script/src/edge/functions.ts";
+var USERFUNCTIONS_META_KEY = "dxos.org/service/function";
+var USERFUNCTIONS_CREDENTIAL_CAPABILITY = "composer:beta";
+var defaultUserFunctionsBaseUrl = "http://localhost:8600";
+var getBaseUrl = (config) => {
+  return config.get("runtime.app.env.DX_USERFUNCTIONS_BASE_URL") || defaultUserFunctionsBaseUrl;
+};
+var uploadWorkerFunction = async ({ clientConfig, halo, name, source, ownerDid, functionId, credentialLoadTimeout }) => {
+  const identity = halo.identity.get();
+  if (!identity) {
+    throw new Error("Identity not available");
+  }
+  const userFunctionsBaseUrl = getBaseUrl(clientConfig);
+  const uploadUrl = `${userFunctionsBaseUrl}/${ownerDid}` + (functionId ? `/${functionId}` : "");
+  (0, import_log.log)("Upload", {
+    functionId,
+    source,
+    name,
+    identityKey: identity.identityKey,
+    uploadUrl: uploadUrl.toString()
+  }, {
+    F: __dxlog_file,
+    L: 65,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  const response = await fetch(uploadUrl, {
+    method: "PUT",
+    body: JSON.stringify({
+      script: source,
+      name
+    }),
+    headers: await presentationForIdentity({
+      halo,
+      timeout: credentialLoadTimeout
+    })
+  });
+  if (!response.ok) {
+    return await response.json();
+  }
+  const res = await response.json();
+  (0, import_log.log)("Upload response", {
+    status: response.status,
+    res
+  }, {
+    F: __dxlog_file,
+    L: 76,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  return res;
+};
+var getUserFunctionUrlInMetadata = (meta) => {
+  return meta.keys.find((key) => key.source === USERFUNCTIONS_META_KEY)?.id;
+};
+var setUserFunctionUrlInMetadata = (meta, functionUrl) => {
+  const key = meta.keys.find((key2) => key2.source === USERFUNCTIONS_META_KEY);
+  if (key) {
+    if (key.id !== functionUrl) {
+      throw new Error("Metadata mismatch");
+    }
+  } else {
+    meta.keys.push({
+      source: USERFUNCTIONS_META_KEY,
+      id: functionUrl
+    });
+  }
+};
+var presentationForIdentity = async ({ halo, timeout }) => {
+  let credential;
+  if (timeout) {
+    const credentialsLoaded = new import_async.Trigger();
+    halo.credentials.subscribe((c) => {
+      credential = c.find(matchServiceCredential([
+        USERFUNCTIONS_CREDENTIAL_CAPABILITY
+      ]));
+      if (credential) {
+        credentialsLoaded.wake();
+      }
+    });
+    await credentialsLoaded.wait({
+      timeout
+    });
+  } else {
+    credential = halo.queryCredentials().toSorted((a, b) => b.issuanceDate.getTime() - a.issuanceDate.getTime()).find(matchServiceCredential([
+      USERFUNCTIONS_CREDENTIAL_CAPABILITY
+    ]));
+  }
+  if (!credential) {
+    throw new Error("No credential found");
+  }
+  (0, import_log.log)("credential found", {
+    credential
+  }, {
+    F: __dxlog_file,
+    L: 122,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  (0, import_invariant.invariant)(credential.id, "beta credential missing id", {
+    F: __dxlog_file,
+    L: 124,
+    S: void 0,
+    A: [
+      "credential.id",
+      "'beta credential missing id'"
+    ]
+  });
+  const presentation = await halo.presentCredentials({
+    ids: [
+      credential.id
+    ]
+  });
+  return {
+    Authorization: `Bearer ${codec.encode(presentation)}`
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HeaderCodec,
+  codec,
+  getUserFunctionUrlInMetadata,
+  matchServiceCredential,
+  publicKeyToDid,
+  setUserFunctionUrlInMetadata,
+  uploadWorkerFunction
+});
+//# sourceMappingURL=chunk-LWUBFTPA.cjs.map

package/dist/lib/node/chunk-LWUBFTPA.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/edge/codec.ts", "../../../src/edge/header-codec.ts", "../../../src/edge/functions.ts", "../../../src/edge/hub-protocol.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { PublicKey } from '@dxos/keys';\n\nimport { HeaderCodec, type EncodedKey } from './header-codec';\n\nexport const codec = new HeaderCodec<PublicKey>({\n  isKey: (value: any): value is PublicKey => value instanceof PublicKey,\n  encode: (key: PublicKey): EncodedKey => ({ __k: key.toHex() }),\n  decode: (value: EncodedKey): PublicKey => PublicKey.fromHex(value.__k),\n});\n", "//\n// Copyright 2024 DXOS.org\n//\n\n// TODO(burdon): Factor out from @dxos/hub-protocol\n\nconst ENCODING = 'base64';\n\nexport type EncodedKey = { __k: string };\n\nexport type EncodedBytes = { __b: string };\n\nexport type EncodedTimestamp = { __t: number };\n\nexport interface KeyCodec<KeyType> {\n  isKey(value: any): value is KeyType;\n  encode(key: KeyType): EncodedKey;\n  decode(value: EncodedKey): KeyType;\n}\n\n// TODO(wittjosiah): Use deepMapValues from @dxos/util -- it handles recursion for you.\nexport class HeaderCodec<Key> {\n  constructor(private readonly _keyCodec: KeyCodec<Key>) {}\n\n  encode(obj: any): string {\n    const objectToEncode = this._prepareForEncoding(obj);\n    const encoded = Buffer.from(JSON.stringify(objectToEncode));\n    return encoded.toString(ENCODING);\n  }\n\n  decode<Type>(buffer: string): Type {\n    const json = JSON.parse(Buffer.from(buffer, ENCODING).toString());\n    return this._decodeRecursive(json);\n  }\n\n  private _decodeRecursive(obj: any): any {\n    return this._recurse(obj, (value) => {\n      if (isEncodedBytes(value)) {\n        return decodeBytes(value.__b);\n      }\n      if (isEncodedKey(value)) {\n        return this._keyCodec.decode(value);\n      }\n      if (isEncodedDate(value)) {\n        return decodeDate(value);\n      }\n      return null;\n    });\n  }\n\n  private _prepareForEncoding(obj: any): any {\n    return this._recurse(obj, (value) => {\n      if (value instanceof Uint8Array) {\n        return { __b: encodeBytes(value) };\n      }\n      if (this._keyCodec.isKey(value)) {\n        return this._keyCodec.encode(value);\n      }\n      if (value instanceof Date) {\n        return encodeDate(value);\n      }\n      return null;\n    });\n  }\n\n  private _recurse(obj: any, handler: (obj: object) => any | null): any {\n    if (typeof obj !== 'object') {\n      return obj;\n    }\n    const handled = handler(obj);\n    if (handled != null) {\n      return handled;\n    }\n    if (Array.isArray(obj)) {\n      const result = [];\n      for (const elem of obj) {\n        result.push(this._recurse(elem, handler));\n      }\n      return result;\n    }\n    const result: any = {};\n    for (const [key, value] of Object.entries(obj)) {\n      result[key] = this._recurse(value, handler);\n    }\n    return result;\n  }\n}\n\nconst isEncodedKey = (obj: object): obj is EncodedKey => '__k' in obj && typeof obj.__k === 'string';\nconst isEncodedBytes = (obj: object): obj is EncodedBytes => '__b' in obj && typeof obj.__b === 'string';\nconst isEncodedDate = (obj: object): obj is EncodedTimestamp => '__t' in obj && typeof obj.__t === 'number';\n\nconst encodeDate = (date: Date) => ({ __t: date.getTime() });\nconst decodeDate = (timestamp: EncodedTimestamp) => new Date(timestamp.__t);\n\nconst encodeBytes = (bytes: Uint8Array) => Buffer.from(bytes).toString(ENCODING);\nconst decodeBytes = (bytes: string) => Buffer.from(bytes, ENCODING);\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport { type DID } from 'iso-did/types';\n\nimport { Trigger } from '@dxos/async';\nimport { type Config } from '@dxos/client';\nimport { type Halo } from '@dxos/client-protocol';\nimport { type ObjectMeta } from '@dxos/echo-schema';\nimport { invariant } from '@dxos/invariant';\nimport { log } from '@dxos/log';\nimport { type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';\n\nimport { codec } from './codec';\nimport { matchServiceCredential } from './hub-protocol';\n\n// TODO: use URL scheme for source?\nconst USERFUNCTIONS_META_KEY = 'dxos.org/service/function';\nconst USERFUNCTIONS_CREDENTIAL_CAPABILITY = 'composer:beta';\n\n// TODO: Synchronize API types with server\nexport type UserFunctionUploadResult = {\n  result: 'success' | 'error';\n  errorMessage?: string;\n  functionId?: string;\n  functionVersionNumber?: number;\n};\n\nexport type UploadWorkerProps = {\n  clientConfig: Config;\n  halo: Halo;\n  name?: string;\n  source: string;\n  functionId?: string;\n  ownerDid: DID;\n  credentialLoadTimeout?: number; // ms to wait for credentials to load\n};\n\nconst defaultUserFunctionsBaseUrl = 'http://localhost:8600';\n// const userFunctionsBaseUrl = 'https://functions-nftest.dxos.workers.dev';\n\nconst getBaseUrl = (config: Config) => {\n  return config.get('runtime.app.env.DX_USERFUNCTIONS_BASE_URL') || defaultUserFunctionsBaseUrl;\n};\n\nexport const uploadWorkerFunction = async ({\n  clientConfig,\n  halo,\n  name,\n  source,\n  ownerDid,\n  functionId,\n  credentialLoadTimeout,\n}: UploadWorkerProps) => {\n  const identity = halo.identity.get();\n  if (!identity) {\n    throw new Error('Identity not available');\n  }\n  const userFunctionsBaseUrl = getBaseUrl(clientConfig);\n\n  // TODO: codify naming convention\n  const uploadUrl = `${userFunctionsBaseUrl}/${ownerDid}` + (functionId ? `/${functionId}` : '');\n\n  log('Upload', { functionId, source, name, identityKey: identity.identityKey, uploadUrl: uploadUrl.toString() });\n  const response = await fetch(uploadUrl, {\n    method: 'PUT',\n    body: JSON.stringify({ script: source, name }),\n    headers: await presentationForIdentity({ halo, timeout: credentialLoadTimeout }),\n  });\n  if (!response.ok) {\n    return (await response.json()) as UserFunctionUploadResult;\n  }\n\n  const res = await response.json();\n  log('Upload response', { status: response.status, res });\n\n  return res as UserFunctionUploadResult;\n};\n\nexport const getUserFunctionUrlInMetadata = (meta: ObjectMeta) => {\n  return meta.keys.find((key) => key.source === USERFUNCTIONS_META_KEY)?.id;\n};\n\nexport const setUserFunctionUrlInMetadata = (meta: ObjectMeta, functionUrl: string) => {\n  const key = meta.keys.find((key) => key.source === USERFUNCTIONS_META_KEY);\n  if (key) {\n    if (key.id !== functionUrl) {\n      throw new Error('Metadata mismatch');\n    }\n  } else {\n    meta.keys.push({ source: USERFUNCTIONS_META_KEY, id: functionUrl });\n  }\n};\n\n// TODO: handle team owner\n\nconst presentationForIdentity = async ({ halo, timeout }: { halo: Halo; timeout?: number }) => {\n  let credential: Credential | undefined;\n\n  if (timeout) {\n    const credentialsLoaded = new Trigger();\n    halo.credentials.subscribe((c) => {\n      credential = c.find(matchServiceCredential([USERFUNCTIONS_CREDENTIAL_CAPABILITY]));\n      if (credential) {\n        credentialsLoaded.wake();\n      }\n    });\n    await credentialsLoaded.wait({\n      timeout,\n    });\n  } else {\n    credential = halo\n      .queryCredentials()\n      .toSorted((a, b) => b.issuanceDate.getTime() - a.issuanceDate.getTime())\n      .find(matchServiceCredential([USERFUNCTIONS_CREDENTIAL_CAPABILITY]));\n  }\n\n  if (!credential) {\n    throw new Error('No credential found');\n  }\n  log('credential found', { credential });\n  // TODO(wittjosiah): If id is required to present credentials, then it should always be present for queried credentials.\n  invariant(credential.id, 'beta credential missing id');\n  const presentation = await halo.presentCredentials({ ids: [credential.id] });\n\n  return { Authorization: `Bearer ${codec.encode(presentation)}` };\n};\n", "//\n// Copyright 2024 DXOS.org\n//\n\nimport { type DID } from 'iso-did/types';\n\nimport { type Credential } from '@dxos/client/halo';\nimport { type PublicKey } from '@dxos/keys';\n\n// TODO(burdon): Factor out to @dxos/hub-protocol.\n\nexport const matchServiceCredential =\n  (capabilities: string[] = []) =>\n  (credential: Credential) => {\n    if (credential.subject.assertion['@type'] !== 'dxos.halo.credentials.ServiceAccess') {\n      return false;\n    }\n\n    const { capabilities: credentialCapabilities } = credential.subject.assertion;\n    return capabilities.every((capability) => credentialCapabilities.includes(capability));\n  };\n\n// TODO: reconcile with @dxos/hub-protocol\n\nexport const publicKeyToDid = (key: PublicKey): DID => {\n  return `did:key:${key.toHex()}`;\n};\n"],
+  "mappings": "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",
+  "names": ["ENCODING", "HeaderCodec", "constructor", "_keyCodec", "encode", "obj", "objectToEncode", "_prepareForEncoding", "encoded", "Buffer", "from", "JSON", "stringify", "toString", "decode", "buffer", "json", "parse", "_decodeRecursive", "_recurse", "value", "isEncodedBytes", "decodeBytes", "__b", "isEncodedKey", "isEncodedDate", "decodeDate", "Uint8Array", "encodeBytes", "isKey", "Date", "encodeDate", "handler", "handled", "Array", "isArray", "result", "elem", "push", "key", "Object", "entries", "__k", "__t", "date", "getTime", "timestamp", "bytes", "codec", "PublicKey", "toHex", "fromHex", "matchServiceCredential", "capabilities", "credential", "subject", "assertion", "credentialCapabilities", "every", "capability", "includes", "publicKeyToDid", "USERFUNCTIONS_META_KEY", "USERFUNCTIONS_CREDENTIAL_CAPABILITY", "defaultUserFunctionsBaseUrl", "getBaseUrl", "config", "get", "uploadWorkerFunction", "clientConfig", "halo", "name", "source", "ownerDid", "functionId", "credentialLoadTimeout", "identity", "Error", "userFunctionsBaseUrl", "uploadUrl", "log", "identityKey", "response", "fetch", "method", "body", "script", "headers", "presentationForIdentity", "timeout", "ok", "res", "status", "getUserFunctionUrlInMetadata", "meta", "keys", "find", "id", "setUserFunctionUrlInMetadata", "functionUrl", "credentialsLoaded", "Trigger", "credentials", "subscribe", "c", "wake", "wait", "queryCredentials", "toSorted", "a", "b", "issuanceDate", "invariant", "presentation", "presentCredentials", "ids", "Authorization"]
+}

package/dist/lib/node/chunk-SLV3SDZE.cjs

@@ -0,0 +1,93 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_SLV3SDZE_exports = {};
+__export(chunk_SLV3SDZE_exports, {
+  TypescriptEditor: () => TypescriptEditor,
+  TypescriptEditor_default: () => TypescriptEditor_default
+});
+module.exports = __toCommonJS(chunk_SLV3SDZE_exports);
+var import_lang_javascript = require("@codemirror/lang-javascript");
+var import_language = require("@codemirror/language");
+var import_theme_one_dark = require("@codemirror/theme-one-dark");
+var import_react = __toESM(require("react"));
+var import_react_ui = require("@dxos/react-ui");
+var import_react_ui_editor = require("@dxos/react-ui-editor");
+var import_util = require("@dxos/util");
+var TypescriptEditor = ({ id, extensions, initialValue, scrollTo, selection, className, scrollPastEnd }) => {
+  const { themeMode } = (0, import_react_ui.useThemeContext)();
+  const { parentRef, focusAttributes } = (0, import_react_ui_editor.useTextEditor)(() => ({
+    id,
+    initialValue,
+    extensions: [
+      extensions,
+      // TODO(wittjosiah): Highlight active line doesn't work.
+      (0, import_react_ui_editor.createBasicExtensions)({
+        highlightActiveLine: true,
+        indentWithTab: true,
+        lineNumbers: true,
+        scrollPastEnd
+      }),
+      // TODO(wittjosiah): Factor out syntax highlighting to theme extensions.
+      themeMode === "dark" ? (0, import_language.syntaxHighlighting)(import_theme_one_dark.oneDarkHighlightStyle) : (0, import_language.syntaxHighlighting)(import_language.defaultHighlightStyle),
+      (0, import_react_ui_editor.createThemeExtensions)({
+        themeMode,
+        slots: {
+          content: {
+            className: import_react_ui_editor.editorContent
+          }
+        }
+      }),
+      (0, import_lang_javascript.javascript)({
+        typescript: true
+      }),
+      (0, import_react_ui_editor.autocomplete)()
+    ].filter(import_util.nonNullable),
+    selection,
+    scrollTo
+  }), [
+    id,
+    initialValue,
+    extensions,
+    themeMode,
+    selection,
+    scrollTo
+  ]);
+  return /* @__PURE__ */ import_react.default.createElement("div", {
+    ref: parentRef,
+    className,
+    ...focusAttributes
+  });
+};
+var TypescriptEditor_default = TypescriptEditor;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TypescriptEditor,
+  TypescriptEditor_default
+});
+//# sourceMappingURL=chunk-SLV3SDZE.cjs.map

package/dist/lib/node/chunk-SLV3SDZE.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/components/TypescriptEditor.tsx"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { javascript } from '@codemirror/lang-javascript';\nimport { defaultHighlightStyle, syntaxHighlighting } from '@codemirror/language';\nimport { oneDarkHighlightStyle } from '@codemirror/theme-one-dark';\nimport React from 'react';\n\nimport { useThemeContext } from '@dxos/react-ui';\nimport {\n  autocomplete,\n  createBasicExtensions,\n  createThemeExtensions,\n  editorContent,\n  useTextEditor,\n  type UseTextEditorProps,\n} from '@dxos/react-ui-editor';\nimport { nonNullable } from '@dxos/util';\n\nexport type TypescriptEditorProps = {\n  id: string;\n  className?: string;\n  scrollPastEnd?: boolean;\n} & Pick<UseTextEditorProps, 'initialValue' | 'extensions' | 'scrollTo' | 'selection'>;\n\nexport const TypescriptEditor = ({\n  id,\n  extensions,\n  initialValue,\n  scrollTo,\n  selection,\n  className,\n  scrollPastEnd,\n}: TypescriptEditorProps) => {\n  const { themeMode } = useThemeContext();\n\n  const { parentRef, focusAttributes } = useTextEditor(\n    () => ({\n      id,\n      initialValue,\n      extensions: [\n        extensions,\n        // TODO(wittjosiah): Highlight active line doesn't work.\n        createBasicExtensions({ highlightActiveLine: true, indentWithTab: true, lineNumbers: true, scrollPastEnd }),\n        // TODO(wittjosiah): Factor out syntax highlighting to theme extensions.\n        themeMode === 'dark' ? syntaxHighlighting(oneDarkHighlightStyle) : syntaxHighlighting(defaultHighlightStyle),\n        createThemeExtensions({\n          themeMode,\n          slots: {\n            content: { className: editorContent },\n          },\n        }),\n        javascript({ typescript: true }),\n        autocomplete(),\n      ].filter(nonNullable),\n      selection,\n      scrollTo,\n    }),\n    [id, initialValue, extensions, themeMode, selection, scrollTo],\n  );\n\n  return <div ref={parentRef} className={className} {...focusAttributes} />;\n};\n\nexport default TypescriptEditor;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,6BAA2B;AAC3B,sBAA0D;AAC1D,4BAAsC;AACtC,mBAAkB;AAElB,sBAAgC;AAChC,6BAOO;AACP,kBAA4B;AAQrB,IAAMA,mBAAmB,CAAC,EAC/BC,IACAC,YACAC,cACAC,UACAC,WACAC,WACAC,cAAa,MACS;AACtB,QAAM,EAAEC,UAAS,QAAKC,iCAAAA;AAEtB,QAAM,EAAEC,WAAWC,gBAAe,QAAKC,sCACrC,OAAO;IACLX;IACAE;IACAD,YAAY;MACVA;;UAEAW,8CAAsB;QAAEC,qBAAqB;QAAMC,eAAe;QAAMC,aAAa;QAAMT;MAAc,CAAA;;MAEzGC,cAAc,aAASS,oCAAmBC,2CAAAA,QAAyBD,oCAAmBE,qCAAAA;UACtFC,8CAAsB;QACpBZ;QACAa,OAAO;UACLC,SAAS;YAAEhB,WAAWiB;UAAc;QACtC;MACF,CAAA;UACAC,mCAAW;QAAEC,YAAY;MAAK,CAAA;UAC9BC,qCAAAA;MACAC,OAAOC,uBAAAA;IACTvB;IACAD;EACF,IACA;IAACH;IAAIE;IAAcD;IAAYM;IAAWH;IAAWD;GAAS;AAGhE,SAAO,6BAAAyB,QAAA,cAACC,OAAAA;IAAIC,KAAKrB;IAAWJ;IAAuB,GAAGK;;AACxD;AAEA,IAAA,2BAAeX;",
+  "names": ["TypescriptEditor", "id", "extensions", "initialValue", "scrollTo", "selection", "className", "scrollPastEnd", "themeMode", "useThemeContext", "parentRef", "focusAttributes", "useTextEditor", "createBasicExtensions", "highlightActiveLine", "indentWithTab", "lineNumbers", "syntaxHighlighting", "oneDarkHighlightStyle", "defaultHighlightStyle", "createThemeExtensions", "slots", "content", "editorContent", "javascript", "typescript", "autocomplete", "filter", "nonNullable", "React", "div", "ref"]
+}

package/dist/lib/node/edge/index.cjs

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var edge_exports = {};
+__export(edge_exports, {
+  HeaderCodec: () => import_chunk_LWUBFTPA.HeaderCodec,
+  codec: () => import_chunk_LWUBFTPA.codec,
+  getUserFunctionUrlInMetadata: () => import_chunk_LWUBFTPA.getUserFunctionUrlInMetadata,
+  matchServiceCredential: () => import_chunk_LWUBFTPA.matchServiceCredential,
+  publicKeyToDid: () => import_chunk_LWUBFTPA.publicKeyToDid,
+  setUserFunctionUrlInMetadata: () => import_chunk_LWUBFTPA.setUserFunctionUrlInMetadata,
+  uploadWorkerFunction: () => import_chunk_LWUBFTPA.uploadWorkerFunction
+});
+module.exports = __toCommonJS(edge_exports);
+var import_chunk_LWUBFTPA = require("../chunk-LWUBFTPA.cjs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HeaderCodec,
+  codec,
+  getUserFunctionUrlInMetadata,
+  matchServiceCredential,
+  publicKeyToDid,
+  setUserFunctionUrlInMetadata,
+  uploadWorkerFunction
+});
+//# sourceMappingURL=index.cjs.map

package/dist/lib/node/edge/index.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["index.cjs"],
+  "sourcesContent": ["import {\n  HeaderCodec,\n  codec,\n  getUserFunctionUrlInMetadata,\n  matchServiceCredential,\n  publicKeyToDid,\n  setUserFunctionUrlInMetadata,\n  uploadWorkerFunction\n} from \"../chunk-LWUBFTPA.cjs\";\nexport {\n  HeaderCodec,\n  codec,\n  getUserFunctionUrlInMetadata,\n  matchServiceCredential,\n  publicKeyToDid,\n  setUserFunctionUrlInMetadata,\n  uploadWorkerFunction\n};\n//# sourceMappingURL=index.cjs.map\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,4BAQO;",
+  "names": []
+}