@typespec/playground 0.3.0-dev.8 → 0.3.0

package/dist/state-storage-BjOULkS3.js

@@ -0,0 +1,654 @@
+import { createSourceFile, getSourceFileKindFromExt, resolvePath, TypeSpecLanguageConfiguration } from '@typespec/compiler';
+import * as monaco from 'monaco-editor';
+import * as lsp from 'vscode-languageserver';
+import { DiagnosticSeverity, FormattingOptions, DocumentHighlightKind } from 'vscode-languageserver';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import lzutf8 from 'lzutf8';
+
+async function importTypeSpecCompiler(config) {
+  return await importLibrary("@typespec/compiler", config);
+}
+async function importLibrary(name, config) {
+  return config.useShim ? importShim(name) : import(
+    /* @vite-ignore */
+    /* webpackIgnore: true */
+    name
+  );
+}
+async function importShim(name) {
+  return window.importShim(name);
+}
+
+function resolveVirtualPath(path, ...paths) {
+  return resolvePath("/test", path, ...paths);
+}
+function createBrowserHostInternal(options) {
+  const virtualFs = /* @__PURE__ */ new Map();
+  const jsImports = /* @__PURE__ */ new Map();
+  const libraries = options.libraries;
+  for (const [libName, { _TypeSpecLibrary_ }] of Object.entries(libraries)) {
+    for (const [key, value] of Object.entries(_TypeSpecLibrary_.typespecSourceFiles)) {
+      virtualFs.set(`/test/node_modules/${libName}/${key}`, value);
+    }
+    for (const [key, value] of Object.entries(_TypeSpecLibrary_.jsSourceFiles)) {
+      addJsImport(`/test/node_modules/${libName}/${key}`, value);
+    }
+  }
+  virtualFs.set(
+    `/test/package.json`,
+    JSON.stringify({
+      name: "playground-pkg",
+      dependencies: Object.fromEntries(
+        Object.values(libraries).map((x) => [x.name, x.packageJson.version])
+      )
+    })
+  );
+  function addJsImport(path, value) {
+    virtualFs.set(path, "");
+    jsImports.set(path, value);
+  }
+  return {
+    compiler: options.compiler,
+    libraries,
+    async readUrl(url) {
+      const contents = virtualFs.get(url);
+      if (contents === void 0) {
+        const e = new Error(`File ${url} not found.`);
+        e.code = "ENOENT";
+        throw e;
+      }
+      return createSourceFile(contents, url);
+    },
+    async readFile(path) {
+      path = resolveVirtualPath(path);
+      const contents = virtualFs.get(path);
+      if (contents === void 0) {
+        const e = new Error(`File ${path} not found.`);
+        e.code = "ENOENT";
+        throw e;
+      }
+      return createSourceFile(contents, path);
+    },
+    async writeFile(path, content) {
+      path = resolveVirtualPath(path);
+      virtualFs.set(path, content);
+    },
+    async readDir(path) {
+      path = resolveVirtualPath(path);
+      const fileFolder = [...virtualFs.keys()].filter((x) => x.startsWith(`${path}/`)).map((x) => x.replace(`${path}/`, "")).map((x) => {
+        const index = x.indexOf("/");
+        return index !== -1 ? x.substring(0, index) : x;
+      });
+      return [...new Set(fileFolder)];
+    },
+    async rm(path) {
+      path = resolveVirtualPath(path);
+      for (const key of virtualFs.keys()) {
+        if (key === path || key.startsWith(`${path}/`)) {
+          virtualFs.delete(key);
+        }
+      }
+    },
+    getLibDirs() {
+      if (virtualFs.has(resolveVirtualPath("/test/node_modules/@typespec/compiler/lib/std/main.tsp"))) {
+        return [resolveVirtualPath("/test/node_modules/@typespec/compiler/lib/std")];
+      } else {
+        return [resolveVirtualPath("/test/node_modules/@typespec/compiler/lib")];
+      }
+    },
+    getExecutionRoot() {
+      return resolveVirtualPath("/test/node_modules/@typespec/compiler");
+    },
+    async getJsImport(path) {
+      path = resolveVirtualPath(path);
+      const module = await jsImports.get(path);
+      if (module === void 0) {
+        const e = new Error(`Module ${path} not found`);
+        e.code = "MODULE_NOT_FOUND";
+        throw e;
+      }
+      return module;
+    },
+    async stat(path) {
+      path = resolveVirtualPath(path);
+      if (virtualFs.has(path)) {
+        return {
+          isDirectory() {
+            return false;
+          },
+          isFile() {
+            return true;
+          }
+        };
+      }
+      for (const fsPath of virtualFs.keys()) {
+        if (fsPath.startsWith(path) && fsPath !== path) {
+          return {
+            isDirectory() {
+              return true;
+            },
+            isFile() {
+              return false;
+            }
+          };
+        }
+      }
+      const e = new Error(`File ${path} not found.`);
+      e.code = "ENOENT";
+      throw e;
+    },
+    // symlinks not supported in test-host
+    async realpath(path) {
+      return path;
+    },
+    getSourceFileKind: getSourceFileKindFromExt,
+    logSink: console,
+    mkdirp: async (path) => path,
+    fileURLToPath(path) {
+      return path.replace("inmemory:/", "");
+    },
+    pathToFileURL(path) {
+      return "inmemory:/" + resolveVirtualPath(path);
+    }
+  };
+}
+async function createBrowserHost(libsToLoad, importOptions = {}) {
+  const libraries = {};
+  for (const libName of libsToLoad) {
+    const { _TypeSpecLibrary_, $lib, $linter } = await importLibrary(
+      libName,
+      importOptions
+    );
+    libraries[libName] = {
+      name: libName,
+      isEmitter: $lib?.emitter,
+      definition: $lib,
+      packageJson: JSON.parse(_TypeSpecLibrary_.typespecSourceFiles["package.json"]),
+      linter: $linter,
+      _TypeSpecLibrary_
+    };
+  }
+  return createBrowserHostInternal({
+    compiler: await importTypeSpecCompiler(importOptions),
+    libraries
+  });
+}
+
+function range(range2) {
+  return {
+    startColumn: range2.start.character + 1,
+    startLineNumber: range2.start.line + 1,
+    endColumn: range2.end.character + 1,
+    endLineNumber: range2.end.line + 1
+  };
+}
+function foldingRange(range2) {
+  return {
+    start: range2.startLine + 1,
+    end: range2.endLine + 1,
+    kind: range2.kind ? new monaco.languages.FoldingRangeKind(range2.kind) : void 0
+  };
+}
+function textEdits(edit) {
+  return edit.map(textEdit);
+}
+function textEdit(edit) {
+  return {
+    range: range(edit.range),
+    text: edit.newText
+  };
+}
+function signatureHelp(help) {
+  return {
+    signatures: help?.signatures.map((x) => ({
+      ...x,
+      parameters: x.parameters ?? []
+    })) ?? [],
+    activeSignature: help?.activeSignature ?? 0,
+    activeParameter: help?.activeParameter ?? 0
+  };
+}
+function command(command2) {
+  return {
+    id: command2.command,
+    title: command2.title,
+    arguments: command2.arguments
+  };
+}
+function severity(severity2) {
+  switch (severity2) {
+    case DiagnosticSeverity.Error:
+      return monaco.MarkerSeverity.Error;
+    case DiagnosticSeverity.Warning:
+      return monaco.MarkerSeverity.Warning;
+    case DiagnosticSeverity.Hint:
+      return monaco.MarkerSeverity.Hint;
+    case DiagnosticSeverity.Information:
+      return monaco.MarkerSeverity.Info;
+  }
+}
+function diagnostic(diagnostic2) {
+  return {
+    severity: diagnostic2.severity ? severity(diagnostic2.severity) : monaco.MarkerSeverity.Error,
+    message: diagnostic2.message,
+    code: diagnostic2.code?.toString(),
+    source: diagnostic2.source,
+    startLineNumber: diagnostic2.range.start.line + 1,
+    startColumn: diagnostic2.range.start.character + 1,
+    endLineNumber: diagnostic2.range.end.line + 1,
+    endColumn: diagnostic2.range.end.character + 1
+  };
+}
+function codeAction(action) {
+  return {
+    title: action.title,
+    kind: action.kind,
+    diagnostics: action.diagnostics?.map(diagnostic),
+    command: action.command && command(action.command)
+  };
+}
+const LspToMonaco = {
+  range,
+  foldingRange,
+  textEdits,
+  textEdit,
+  signatureHelp,
+  codeAction,
+  command
+};
+
+function getIndentAction(value) {
+  switch (value) {
+    case "none":
+      return monaco.languages.IndentAction.None;
+    case "indent":
+      return monaco.languages.IndentAction.Indent;
+    case "indentOutdent":
+      return monaco.languages.IndentAction.IndentOutdent;
+    case "outdent":
+      return monaco.languages.IndentAction.Outdent;
+  }
+}
+function getTypeSpecLanguageConfiguration() {
+  return {
+    ...TypeSpecLanguageConfiguration,
+    onEnterRules: TypeSpecLanguageConfiguration.onEnterRules.map((rule) => {
+      return {
+        beforeText: new RegExp(rule.beforeText.pattern),
+        previousLineText: "previousLineText" in rule ? new RegExp(rule.previousLineText.pattern) : void 0,
+        action: {
+          indentAction: getIndentAction(rule.action.indent),
+          appendText: "appendText" in rule.action ? rule.action.appendText : void 0,
+          removeText: "removeText" in rule.action ? rule.action.removeText : void 0
+        }
+      };
+    })
+  };
+}
+async function registerMonacoLanguage(host) {
+  monaco.languages.register({ id: "typespec", extensions: [".tsp"] });
+  monaco.languages.setLanguageConfiguration("typespec", getTypeSpecLanguageConfiguration());
+  const serverHost = {
+    compilerHost: host,
+    getOpenDocumentByURL(url) {
+      const model = monaco.editor.getModel(monaco.Uri.parse(url));
+      return model ? textDocumentForModel(model) : void 0;
+    },
+    sendDiagnostics() {
+    },
+    log: (log) => {
+      switch (log.level) {
+        case "error":
+          console.error(log);
+          break;
+        case "warning":
+          console.warn(log);
+          break;
+        case "info":
+          console.info(log);
+          break;
+        case "debug":
+          console.debug(log);
+          break;
+      }
+    },
+    applyEdit(param) {
+      return Promise.resolve({ applied: false });
+    }
+  };
+  const { createServer } = host.compiler;
+  const serverLib = createServer(serverHost);
+  const lsConfig = await serverLib.initialize({
+    capabilities: {},
+    processId: 1,
+    workspaceFolders: [],
+    rootUri: "inmemory://"
+  });
+  serverLib.initialized({});
+  function textDocumentForModel(model) {
+    return TextDocument.create(
+      model.uri.toString(),
+      "typespec",
+      model.getVersionId(),
+      model.getValue()
+    );
+  }
+  function lspDocumentArgs(model) {
+    return {
+      textDocument: textDocumentForModel(model)
+    };
+  }
+  function lspArgs(model, pos) {
+    return {
+      ...lspDocumentArgs(model),
+      position: lspPosition(pos)
+    };
+  }
+  function lspPosition(pos) {
+    return {
+      line: pos.lineNumber - 1,
+      character: pos.column - 1
+    };
+  }
+  function lspFormattingOptions(options) {
+    return FormattingOptions.create(options.tabSize, options.insertSpaces);
+  }
+  function monacoLocation(loc) {
+    return {
+      uri: monaco.Uri.parse(loc.uri),
+      range: LspToMonaco.range(loc.range)
+    };
+  }
+  function monacoDocumentHighlight(highlight) {
+    return {
+      range: LspToMonaco.range(highlight.range),
+      kind: monacoDocumentHighlightKind(highlight.kind)
+    };
+  }
+  function monacoDocumentHighlightKind(kind) {
+    switch (kind) {
+      case DocumentHighlightKind.Text:
+        return monaco.languages.DocumentHighlightKind.Text;
+      case DocumentHighlightKind.Read:
+        return monaco.languages.DocumentHighlightKind.Read;
+      case DocumentHighlightKind.Write:
+        return monaco.languages.DocumentHighlightKind.Write;
+      default:
+        return void 0;
+    }
+  }
+  function monacoHoverContents(contents) {
+    return [{ value: contents.value }];
+  }
+  function monacoHover(hover) {
+    if (Array.isArray(hover.contents) || lsp.MarkedString.is(hover.contents)) {
+      throw new Error("MarkedString (deprecated) not supported.");
+    }
+    return {
+      contents: monacoHoverContents(hover.contents),
+      range: hover.range ? LspToMonaco.range(hover.range) : void 0
+    };
+  }
+  function monacoWorkspaceEdit(edit) {
+    const edits = [];
+    for (const [uri, changes] of Object.entries(edit.changes ?? {})) {
+      const resource = monaco.Uri.parse(uri);
+      for (const change of changes) {
+        edits.push({ resource, textEdit: LspToMonaco.textEdit(change), versionId: void 0 });
+      }
+    }
+    return { edits };
+  }
+  monaco.languages.registerDefinitionProvider("typespec", {
+    async provideDefinition(model, position) {
+      const results = await serverLib.gotoDefinition(lspArgs(model, position));
+      return results.map(monacoLocation);
+    }
+  });
+  monaco.languages.registerReferenceProvider("typespec", {
+    async provideReferences(model, position, context) {
+      const results = await serverLib.findReferences({ ...lspArgs(model, position), context });
+      return results.map(monacoLocation);
+    }
+  });
+  monaco.languages.registerRenameProvider("typespec", {
+    async resolveRenameLocation(model, position) {
+      const result = await serverLib.prepareRename(lspArgs(model, position));
+      if (!result) {
+        throw new Error("This element can't be renamed.");
+      }
+      const text = model.getWordAtPosition(position)?.word;
+      if (!text) {
+        throw new Error("Failed to obtain word at position.");
+      }
+      return { text, range: LspToMonaco.range(result) };
+    },
+    async provideRenameEdits(model, position, newName) {
+      const result = await serverLib.rename({ ...lspArgs(model, position), newName });
+      return monacoWorkspaceEdit(result);
+    }
+  });
+  monaco.languages.registerFoldingRangeProvider("typespec", {
+    async provideFoldingRanges(model) {
+      const ranges = await serverLib.getFoldingRanges(lspDocumentArgs(model));
+      const output = ranges.map(LspToMonaco.foldingRange);
+      return output;
+    }
+  });
+  monaco.languages.registerHoverProvider("typespec", {
+    async provideHover(model, position) {
+      const hover = await serverLib.getHover(lspArgs(model, position));
+      return monacoHover(hover);
+    }
+  });
+  monaco.languages.registerSignatureHelpProvider("typespec", {
+    signatureHelpTriggerCharacters: ["(", ",", "<"],
+    signatureHelpRetriggerCharacters: [")"],
+    async provideSignatureHelp(model, position) {
+      const help = await serverLib.getSignatureHelp(lspArgs(model, position));
+      return { value: LspToMonaco.signatureHelp(help), dispose: () => {
+      } };
+    }
+  });
+  monaco.languages.registerDocumentFormattingEditProvider("typespec", {
+    async provideDocumentFormattingEdits(model, options, token) {
+      const edits = await serverLib.formatDocument({
+        ...lspDocumentArgs(model),
+        options: lspFormattingOptions(options)
+      });
+      return LspToMonaco.textEdits(edits);
+    }
+  });
+  monaco.languages.registerDocumentHighlightProvider("typespec", {
+    async provideDocumentHighlights(model, position) {
+      const highlights = await serverLib.findDocumentHighlight(lspArgs(model, position));
+      return highlights.map(monacoDocumentHighlight);
+    }
+  });
+  monaco.languages.registerCompletionItemProvider("typespec", {
+    triggerCharacters: lsConfig.capabilities.completionProvider.triggerCharacters,
+    async provideCompletionItems(model, position) {
+      const result = await serverLib.complete(lspArgs(model, position));
+      const word = model.getWordUntilPosition(position);
+      const range = {
+        startLineNumber: position.lineNumber,
+        endLineNumber: position.lineNumber,
+        startColumn: word.startColumn,
+        endColumn: word.endColumn
+      };
+      const suggestions = [];
+      for (const item of result.items) {
+        let itemRange = range;
+        let insertText = item.insertText ?? item.label;
+        if (item.textEdit && "range" in item.textEdit) {
+          itemRange = LspToMonaco.range(item.textEdit.range);
+          insertText = item.textEdit.newText;
+        }
+        suggestions.push({
+          label: item.label,
+          kind: item.kind,
+          documentation: item.documentation,
+          insertText,
+          range: itemRange,
+          commitCharacters: item.commitCharacters ?? lsConfig.capabilities.completionProvider.allCommitCharacters,
+          tags: item.tags
+        });
+      }
+      return { suggestions };
+    }
+  });
+  monaco.editor.defineTheme("typespec", {
+    base: "vs",
+    inherit: true,
+    colors: {},
+    rules: [
+      { token: "macro", foreground: "#800000" },
+      { token: "function", foreground: "#795E26" }
+    ]
+  });
+  monaco.editor.defineTheme("typespec-dark", {
+    base: "vs-dark",
+    inherit: true,
+    colors: {},
+    rules: [
+      { token: "macro", foreground: "#E06C75" },
+      { token: "function", foreground: "#E06C75" }
+    ]
+  });
+  monaco.editor.setTheme("typespec");
+  monaco.languages.registerDocumentSemanticTokensProvider("typespec", {
+    getLegend() {
+      const legend = lsConfig.capabilities.semanticTokensProvider.legend;
+      return {
+        tokenModifiers: legend.tokenModifiers,
+        tokenTypes: legend.tokenTypes.map((entry) => {
+          switch (entry) {
+            case "namespace":
+            case "class":
+            case "enum":
+            case "typeParameter":
+            case "struct":
+            case "interface":
+              return "type";
+            case "property":
+            case "enumMember":
+              return "variable";
+            case "docCommentTag":
+              return "keyword";
+            default:
+              return entry;
+          }
+        })
+      };
+    },
+    async provideDocumentSemanticTokens(model) {
+      const result = await serverLib.buildSemanticTokens(lspDocumentArgs(model));
+      return {
+        resultId: result.resultId,
+        data: new Uint32Array(result.data)
+      };
+    },
+    releaseDocumentSemanticTokens() {
+    }
+  });
+}
+function getMonacoRange(typespecCompiler, target) {
+  const loc = typespecCompiler.getSourceLocation(target);
+  if (loc === void 0 || loc.file.path !== "/test/main.tsp") {
+    return {
+      startLineNumber: 1,
+      startColumn: 1,
+      endLineNumber: 1,
+      endColumn: 1
+    };
+  }
+  const start = loc.file.getLineAndCharacterOfPosition(loc.pos);
+  const end = loc.file.getLineAndCharacterOfPosition(loc.end);
+  return {
+    startLineNumber: start.line + 1,
+    startColumn: start.character + 1,
+    endLineNumber: end.line + 1,
+    endColumn: end.character + 1
+  };
+}
+
+function createUrlStateStorage(schema) {
+  return { load, save, resolveSearchParams };
+  function load() {
+    const result = {};
+    const parsed = new URLSearchParams(window.location.search);
+    for (const [key, item] of Object.entries(schema)) {
+      const value = parsed.get(item.queryParam);
+      const decompressed = value && decompress(item, value);
+      const deserialized = decompressed && deserialize(item, decompressed);
+      if (deserialized) {
+        result[key] = deserialized;
+      }
+    }
+    return result;
+  }
+  function decompress(item, value) {
+    if (item.compress) {
+      try {
+        return lzutf8.decompress(value, { inputEncoding: "Base64" });
+      } catch (e) {
+        console.error(
+          `Error decompressing query parameter ${item.queryParam} with content:`,
+          value
+        );
+        return void 0;
+      }
+    } else {
+      return value;
+    }
+  }
+  function deserialize(item, value) {
+    if (item.type === "object") {
+      try {
+        return JSON.parse(value);
+      } catch (e) {
+        console.error(
+          `Error decompressing query parameter ${item.queryParam} with content:`,
+          value
+        );
+        return void 0;
+      }
+    } else {
+      return value;
+    }
+  }
+  function save(data) {
+    const params = resolveSearchParams(data, true);
+    history.pushState(null, "", window.location.pathname + "?" + params.toString());
+  }
+  function resolveSearchParams(data, mergeWithExisting = false) {
+    const params = new URLSearchParams(mergeWithExisting ? location.search : void 0);
+    for (const [key, item] of Object.entries(schema)) {
+      const value = data[key];
+      if (value) {
+        const serialized = serialize(item, value);
+        const compressed = compress(item, serialized);
+        params.set(item.queryParam, compressed);
+      } else {
+        params.delete(item.queryParam);
+      }
+    }
+    return params;
+  }
+  function compress(item, value) {
+    if (item.compress) {
+      return lzutf8.compress(value, { outputEncoding: "Base64" });
+    } else {
+      return value;
+    }
+  }
+  function serialize(item, value) {
+    if (item.type === "object") {
+      return JSON.stringify(value);
+    } else {
+      return value;
+    }
+  }
+}
+
+export { createUrlStateStorage as a, createBrowserHost as c, getMonacoRange as g, registerMonacoLanguage as r };

package/dist/stories/footer/footer-item.stories.d.ts

@@ -0,0 +1,9 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { FooterItem } from '../../src/react/footer/index.js';
+
+declare const meta: Meta<typeof FooterItem>;
+export default meta;
+type Story = StoryObj<typeof FooterItem>;
+export declare const Default: Story;
+export declare const WithLink: Story;
+//# sourceMappingURL=footer-item.stories.d.ts.map

package/dist/stories/footer/footer-item.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"footer-item.stories.d.ts","sourceRoot":"","sources":["../../../stories/footer/footer-item.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAU,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAErE,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,OAAO,UAAU,CAUjC,CAAC;AAEF,eAAe,IAAI,CAAC;AACpB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,UAAU,CAAC,CAAC;AAEzC,eAAO,MAAM,OAAO,EAAE,KAIrB,CAAC;AACF,eAAO,MAAM,QAAQ,EAAE,KAKtB,CAAC"}

package/dist/stories/footer/footer-version-item.stories.d.ts

@@ -0,0 +1,9 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { FooterVersionItem } from '../../src/react/footer/index.js';
+
+declare const meta: Meta<typeof FooterVersionItem>;
+export default meta;
+type Story = StoryObj<typeof FooterVersionItem>;
+export declare const Readonly: Story;
+export declare const WithSelector: Story;
+//# sourceMappingURL=footer-version-item.stories.d.ts.map

package/dist/stories/footer/footer-version-item.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"footer-version-item.stories.d.ts","sourceRoot":"","sources":["../../../stories/footer/footer-version-item.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAIvD,OAAO,EAEL,iBAAiB,EAElB,MAAM,iCAAiC,CAAC;AAoBzC,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,OAAO,iBAAiB,CAUxC,CAAC;AAEF,eAAe,IAAI,CAAC;AACpB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEhD,eAAO,MAAM,QAAQ,EAAE,KAGtB,CAAC;AAaF,eAAO,MAAM,YAAY,EAAE,KAI1B,CAAC"}

package/dist/stories/footer/footer.stories.d.ts

@@ -0,0 +1,9 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { Footer } from '../../src/react/footer/index.js';
+
+declare const meta: Meta<typeof Footer>;
+export default meta;
+type Story = StoryObj<typeof Footer>;
+export declare const Multiple: Story;
+export declare const VersionItemAndInfo: Story;
+//# sourceMappingURL=footer.stories.d.ts.map

package/dist/stories/footer/footer.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"footer.stories.d.ts","sourceRoot":"","sources":["../../../stories/footer/footer.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAGvD,OAAO,EAAE,MAAM,EAAiC,MAAM,iCAAiC,CAAC;AAoBxF,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,OAAO,MAAM,CAU7B,CAAC;AACF,eAAe,IAAI,CAAC;AACpB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,MAAM,CAAC,CAAC;AAErC,eAAO,MAAM,QAAQ,EAAE,KAUtB,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,KAShC,CAAC"}

package/dist/stories/playground.stories.d.ts

@@ -0,0 +1,9 @@
+import { Meta, StoryObj } from '@storybook/react';
+import { Playground } from '../src/react/playground.js';
+
+declare const meta: Meta<typeof Playground>;
+export default meta;
+type Story = StoryObj<typeof Playground>;
+export declare const Default: Story;
+export declare const CustomViewer: Story;
+//# sourceMappingURL=playground.stories.d.ts.map