@tutorialkit-rb/astro 1.5.2-rb.0.1.0

package/dist/index.js

@@ -0,0 +1,972 @@
+// src/index.ts
+import { fileURLToPath as fileURLToPath4 } from "node:url";
+
+// src/integrations.ts
+import { createRequire } from "node:module";
+import mdx from "@astrojs/mdx";
+import react from "@astrojs/react";
+import { pluginCollapsibleSections } from "@expressive-code/plugin-collapsible-sections";
+import { pluginLineNumbers } from "@expressive-code/plugin-line-numbers";
+import { getInlineContentForPackage } from "@tutorialkit-rb/theme";
+import expressiveCode from "astro-expressive-code";
+import UnoCSS from "unocss/astro";
+function extraIntegrations({
+  root,
+  expressiveCodePlugins = []
+}) {
+  return [
+    react(),
+    expressiveCode({
+      plugins: [pluginCollapsibleSections(), pluginLineNumbers(), ...expressiveCodePlugins],
+      themes: ["dark-plus", "light-plus"],
+      customizeTheme: (theme) => {
+        const isDark = theme.type === "dark";
+        theme.styleOverrides = {
+          borderColor: "var(--tk-border-secondary)",
+          borderWidth: "1px",
+          borderRadius: "var(--code-border-radius, 0px)",
+          frames: {
+            terminalTitlebarBackground: `var(--tk-background-${isDark ? "primary" : "secondary"})`,
+            terminalTitlebarBorderBottomColor: `var(--tk-background-${isDark ? "primary" : "secondary"})`,
+            editorTabBorderRadius: "var(--code-border-radius, 0px)",
+            editorTabBarBackground: `var(--tk-background-${isDark ? "primary" : "secondary"})`
+          }
+        };
+      },
+      themeCssSelector: (theme) => {
+        let customThemeName = "light";
+        if (theme.name === "dark-plus") {
+          customThemeName = "dark";
+        }
+        return `[data-theme='${customThemeName}']`;
+      },
+      defaultProps: {
+        showLineNumbers: false
+      },
+      styleOverrides: {
+        frames: {
+          shadowColor: "none"
+        }
+      }
+    }),
+    mdx(),
+    UnoCSS({
+      configDeps: ["./theme.ts"],
+      injectReset: createRequire(root).resolve("@unocss/reset/tailwind.css"),
+      content: {
+        inline: getInlineContentForPackage({
+          name: "@tutorialkit-rb/astro",
+          pattern: "/dist/default/**/*.astro",
+          root
+        })
+      }
+    })
+  ];
+}
+
+// src/remark/index.ts
+import path2 from "node:path";
+import remarkDirective from "remark-directive";
+
+// src/remark/callouts.ts
+import { h } from "hastscript";
+import {
+  directiveToMarkdown
+} from "mdast-util-directive";
+import { toMarkdown } from "mdast-util-to-markdown";
+import { visit } from "unist-util-visit";
+var callouts = {
+  tip: {
+    title: "Tip",
+    icon: "i-ph-rocket-launch"
+  },
+  info: {
+    title: "Info",
+    icon: "i-ph-info"
+  },
+  warn: {
+    title: "Warning",
+    icon: "i-ph-warning-circle"
+  },
+  success: {
+    title: "Success",
+    icon: "i-ph-check-circle"
+  },
+  danger: {
+    title: "Danger",
+    icon: "i-ph-x-circle"
+  }
+};
+var variants = /* @__PURE__ */ new Set(["tip", "info", "warn", "danger", "success"]);
+function isNodeDirective(node) {
+  return node.type === "textDirective" || node.type === "leafDirective" || node.type === "containerDirective";
+}
+function isContainerDirective(node) {
+  return node.type === "containerDirective";
+}
+function transformUnhandledDirective(node, index, parent) {
+  const textNode = {
+    type: "text",
+    value: toMarkdown(node, { extensions: [directiveToMarkdown()] })
+  };
+  if (node.type === "textDirective") {
+    parent.children[index] = textNode;
+  } else {
+    parent.children[index] = {
+      type: "paragraph",
+      children: [textNode]
+    };
+  }
+}
+function remarkCalloutsPlugin() {
+  return () => {
+    return (tree) => {
+      visit(tree, (node, index, parent) => {
+        if (!parent || index === void 0 || !isNodeDirective(node)) {
+          return;
+        }
+        if (node.type === "textDirective" || node.type === "leafDirective") {
+          transformUnhandledDirective(node, index, parent);
+          return;
+        }
+        if (isContainerDirective(node)) {
+          if (!variants.has(node.name)) {
+            return;
+          }
+          const variant = node.name;
+          const callout = callouts[variant];
+          const data = node.data || (node.data = {});
+          const attributes = node.attributes ?? {};
+          const title = attributes.title ?? callout.title;
+          const noBorder = attributes.noBorder === "true";
+          const hideTitle = attributes.hideTitle === "true";
+          const hideIcon = attributes.hideIcon === "true";
+          const classes = [
+            `callout callout-${variant} my-4 flex flex-col p-3 bg-tk-elements-markdown-callouts-backgroundColor text-tk-elements-markdown-callouts-textColor`,
+            attributes.class ?? "",
+            ...noBorder ? [] : ["border-l-3", "border-tk-elements-markdown-callouts-borderColor"]
+          ];
+          node.attributes = {
+            ...attributes,
+            class: classes.filter((calloutClass) => !!calloutClass).join(" "),
+            "aria-label": title
+          };
+          node.children = generate(title, node.children, callout, hideIcon, hideTitle);
+          const tagName = "aside";
+          const hast = h(tagName, node.attributes);
+          data.hName = hast.tagName;
+          data.hProperties = hast.properties;
+        }
+      });
+    };
+  };
+}
+function generate(title, children, callout, hideIcon, hideTitle) {
+  return [
+    ...hideTitle ? [] : [
+      {
+        type: "paragraph",
+        data: {
+          hName: "div",
+          hProperties: {
+            className: "w-full flex gap-2 items-center text-tk-elements-markdown-callouts-titleTextColor",
+            ariaHidden: true
+          }
+        },
+        children: [
+          ...hideIcon ? [] : [
+            {
+              type: "html",
+              value: `<span class="text-6 inline-block text-tk-elements-markdown-callouts-iconColor ${callout.icon}"></span>`
+            }
+          ],
+          {
+            type: "html",
+            value: `<span class="text-4 font-semibold inline-block"> ${title}</span>`
+          }
+        ]
+      }
+    ],
+    {
+      type: "paragraph",
+      data: {
+        hName: "section",
+        hProperties: { className: ["callout-content mt-1"] }
+      },
+      children
+    }
+  ];
+}
+
+// src/remark/import-file.ts
+import fs from "node:fs";
+import path from "node:path";
+import frontMatter from "front-matter";
+import * as kleur from "kleur/colors";
+import { visit as visit2 } from "unist-util-visit";
+function remarkImportFilePlugin(options) {
+  return () => {
+    return (tree, file) => {
+      if (!file.basename || !/^content\.mdx?$/.test(file.basename)) {
+        return;
+      }
+      const cwd = path.dirname(file.path);
+      const templateName = getTemplateName(file.path);
+      const templatesPath = path.join(options.templatesPath, templateName);
+      visit2(tree, (node) => {
+        if (node.type !== "code") {
+          return void 0;
+        }
+        if (node.lang && /^(files?|solution):/.test(node.lang)) {
+          const relativeFilePath = node.lang.replace(/^(files?|solution):\//, "");
+          let content;
+          if (/^files?\:/.test(node.lang)) {
+            content = tryRead(path.join(cwd, "_files", relativeFilePath), false);
+            if (!content) {
+              content = tryRead(path.join(templatesPath, relativeFilePath));
+            }
+          } else if (node.lang.startsWith("solution:")) {
+            content = tryRead(path.join(cwd, "_solution", relativeFilePath));
+          }
+          if (content) {
+            node.value = content;
+            node.meta ||= "";
+            node.meta += " path=" + node.lang;
+            node.lang = path.extname(relativeFilePath).slice(1);
+          }
+        }
+        return void 0;
+      });
+    };
+  };
+}
+function tryRead(filePath, warn = true) {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    if (warn) {
+      printWarning(`Could not read '${filePath}'. Are you sure this file exists?`);
+    }
+  }
+  return void 0;
+}
+function getTemplateName(file) {
+  const content = fs.readFileSync(file, "utf8");
+  const meta = frontMatter(
+    content
+  );
+  if (meta.attributes.template) {
+    return meta.attributes.template;
+  }
+  if (meta.attributes.type === "tutorial") {
+    return "default";
+  }
+  return getTemplateName(path.join(path.dirname(path.dirname(file)), "meta.md"));
+}
+function printWarning(message) {
+  const time = (/* @__PURE__ */ new Date()).toTimeString().slice(0, 8);
+  console.warn(kleur.yellow(`${kleur.bold(time)} [WARN] [remarkImportFilePlugin] ${message}`));
+}
+
+// src/remark/index.ts
+function updateMarkdownConfig({ updateConfig }) {
+  updateConfig({
+    markdown: {
+      remarkPlugins: [
+        remarkDirective,
+        remarkCalloutsPlugin(),
+        remarkImportFilePlugin({ templatesPath: path2.join(process.cwd(), "src/templates") })
+      ]
+    }
+  });
+}
+
+// src/vite-plugins/core.ts
+import path3 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/utils.ts
+function withResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  return {
+    resolve,
+    reject,
+    promise
+  };
+}
+function normalizeImportPath(importPath) {
+  return importPath.replaceAll("\\", "/");
+}
+
+// src/vite-plugins/core.ts
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+var virtualModuleId = "tutorialkit:core";
+var resolvedVirtualModuleId = `${virtualModuleId}`;
+var tutorialkitCore = {
+  name: "tutorialkit-core-virtual-mod-plugin",
+  resolveId(id) {
+    if (id === virtualModuleId) {
+      return resolvedVirtualModuleId;
+    }
+    return void 0;
+  },
+  async load(id) {
+    if (id === resolvedVirtualModuleId) {
+      const pathToInit = normalizeImportPath(path3.join(__dirname, "default/components/webcontainer.ts"));
+      return `
+        export { webcontainer } from '${pathToInit}';
+      `;
+    }
+    return void 0;
+  }
+};
+
+// src/vite-plugins/css.ts
+import fs2 from "node:fs/promises";
+import path4 from "node:path";
+import { watch } from "chokidar";
+var CUSTOM_PATHS = ["theme.css", "theme/index.css"];
+var virtualModuleId2 = "@tutorialkit/custom.css";
+var resolvedVirtualModuleId2 = `/${virtualModuleId2}`;
+var projectRoot = process.cwd();
+var userlandCSS = {
+  name: "@tutorialkit/custom.css",
+  resolveId(id) {
+    if (id === virtualModuleId2) {
+      return resolvedVirtualModuleId2;
+    }
+    return void 0;
+  },
+  configResolved({ root }) {
+    projectRoot = root;
+  },
+  async load(id) {
+    if (id === resolvedVirtualModuleId2) {
+      const path9 = await findCustomCSSFilePath(projectRoot);
+      if (path9) {
+        return `@import '${path9}';`;
+      } else {
+        return "";
+      }
+    }
+    return void 0;
+  }
+};
+function watchUserlandCSS(server, logger) {
+  const projectRoot2 = server.config.root;
+  const watchedNames = new Map(CUSTOM_PATHS.map((path9) => [path9, false]));
+  const watcher = watch(projectRoot2, {
+    ignoreInitial: true,
+    cwd: projectRoot2,
+    depth: 2,
+    ignored: ["dist", "src", "node_modules"]
+  });
+  watcher.on("all", (eventName, filePath) => {
+    if (eventName === "addDir" || eventName === "unlinkDir" || !watchedNames.has(filePath)) {
+      return;
+    }
+    watchedNames.set(filePath, eventName !== "unlink");
+    checkConflicts(watchedNames, logger);
+    const module = server.moduleGraph.getModuleById(resolvedVirtualModuleId2);
+    if (module) {
+      server.reloadModule(module);
+    }
+  });
+}
+async function findCustomCSSFilePath(projectRoot2) {
+  for (const cssFilePath of CUSTOM_PATHS) {
+    try {
+      const stats = await fs2.stat(path4.join(projectRoot2, cssFilePath));
+      if (stats.isFile()) {
+        return path4.resolve(cssFilePath);
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function checkConflicts(watchedNames, logger) {
+  const conflictCount = [...watchedNames.values()].reduce((count, value) => value ? count + 1 : count, 0);
+  if (conflictCount > 1) {
+    let errorMessage = "";
+    let index = 0;
+    const lastIndex = conflictCount - 1;
+    for (const [configName, isPresent] of watchedNames.entries()) {
+      if (isPresent) {
+        if (index === 0) {
+          errorMessage = `File '${configName}' takes precedences over`;
+        } else if (index === 1) {
+          errorMessage += ` '${configName}'${index === lastIndex ? "." : ""}`;
+        } else if (index !== lastIndex) {
+          errorMessage += `, '${configName}'`;
+        } else {
+          errorMessage += ` and '${configName}'.`;
+        }
+        index += 1;
+      }
+    }
+    errorMessage += " You might want to remove one of those files.";
+    logger.warn(errorMessage);
+  }
+}
+
+// src/vite-plugins/override-components.ts
+var virtualModuleId3 = "tutorialkit:override-components";
+var resolvedId = `\0${virtualModuleId3}`;
+function overrideComponents({ components, defaultRoutes }) {
+  return {
+    name: "tutorialkit-override-components-plugin",
+    resolveId(id) {
+      if (id === virtualModuleId3) {
+        return resolvedId;
+      }
+      return void 0;
+    },
+    async load(id) {
+      if (id === resolvedId) {
+        const topBar = components?.TopBar || resolveDefaultTopBar(defaultRoutes);
+        const headTags = components?.HeadTags || resolveDefaultHeadTags(defaultRoutes);
+        const dialog = components?.Dialog || "@tutorialkit-rb/react/dialog";
+        return `
+          export { default as TopBar } from '${topBar}';
+          export { default as Dialog } from '${dialog}';
+          export { default as HeadTags } from '${headTags}';
+        `;
+      }
+      return void 0;
+    }
+  };
+}
+function resolveDefaultTopBar(defaultRoutes) {
+  if (defaultRoutes) {
+    return "@tutorialkit-rb/astro/default/components/TopBar.astro";
+  }
+  return "./src/components/TopBar.astro";
+}
+function resolveDefaultHeadTags(defaultRoutes) {
+  if (defaultRoutes) {
+    return "@tutorialkit-rb/astro/default/components/HeadTags.astro";
+  }
+  return "./src/components/HeadTags.astro";
+}
+
+// src/vite-plugins/store.ts
+import path5 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var __dirname2 = path5.dirname(fileURLToPath2(import.meta.url));
+var virtualModuleId4 = "tutorialkit:store";
+var resolvedVirtualModuleId3 = `${virtualModuleId4}`;
+var tutorialkitStore = {
+  name: "tutorialkit-store-virtual-mod-plugin",
+  resolveId(id) {
+    if (id === virtualModuleId4) {
+      return resolvedVirtualModuleId3;
+    }
+    return void 0;
+  },
+  async load(id) {
+    if (id === resolvedVirtualModuleId3) {
+      const pathToInit = normalizeImportPath(path5.join(__dirname2, "default/components/webcontainer.ts"));
+      return `
+        import { tutorialStore } from '${pathToInit}';
+        export default tutorialStore;
+      `;
+    }
+    return void 0;
+  }
+};
+
+// src/webcontainer-files/index.ts
+import fs4 from "node:fs";
+import path8 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { watch as watch2 } from "chokidar";
+import { dim as dim2 } from "kleur/colors";
+
+// src/webcontainer-files/cache.ts
+import path7 from "node:path";
+import { dim } from "kleur/colors";
+
+// src/webcontainer-files/constants.ts
+var IGNORED_FILES = ["**/.DS_Store", "**/*.swp", "**/node_modules/**"];
+var EXTEND_CONFIG_FILEPATH = "/.tk-config.json";
+var FILES_FOLDER_NAME = "_files";
+var SOLUTION_FOLDER_NAME = "_solution";
+
+// src/webcontainer-files/filesmap.ts
+import fs3 from "node:fs";
+import path6 from "node:path";
+import glob from "fast-glob";
+import { z } from "zod";
+var configSchema = z.object({
+  extends: z.string()
+}).strict();
+var FilesMapGraph = class {
+  constructor(_nodes = /* @__PURE__ */ new Map()) {
+    this._nodes = _nodes;
+  }
+  getFilesMapByFolder(folder) {
+    try {
+      const resolvedPath = fs3.realpathSync(folder);
+      return this._nodes.get(resolvedPath);
+    } catch {
+      return void 0;
+    }
+  }
+  allFilesMap() {
+    return this._nodes.values();
+  }
+  updateFilesMapByFolder(folder, logger) {
+    const resolvedPath = fs3.realpathSync(folder);
+    let node = this._nodes.get(resolvedPath);
+    if (!node) {
+      node = new FilesMap(resolvedPath);
+      this._nodes.set(resolvedPath, node);
+    }
+    node.update(this._nodes, logger);
+  }
+};
+var FilesMap = class _FilesMap {
+  /**
+   * Construct a new FileMap. To connect it to its graph, call
+   * `FileMap.initGraph` or `init(graph)`.
+   *
+   * @param path resolved path of this file map.
+   */
+  constructor(path9) {
+    this.path = path9;
+  }
+  /**
+   * Initialize the graph of nodes by connecting them to one another.
+   * The graph is expected to be acyclic but this function won't throw any
+   * exception if it isn't.
+   *
+   * Instead when a `FilesMap` is turned into a JSON file, a warning will be
+   * printed if a cycle is found.
+   *
+   * @param folders initial folders found after a lookup.
+   */
+  static async initGraph(folders, logger) {
+    const nodes = /* @__PURE__ */ new Map();
+    const resolvedPaths = await Promise.all(folders.map((folder) => fs3.promises.realpath(folder)));
+    for (const resolvedPath of resolvedPaths) {
+      nodes.set(resolvedPath, new _FilesMap(resolvedPath));
+    }
+    for (const node of nodes.values()) {
+      node.update(nodes, logger);
+    }
+    return new FilesMapGraph(nodes);
+  }
+  _extend = null;
+  _dependents = /* @__PURE__ */ new Set();
+  update(graph, logger) {
+    const configPath = path6.join(this.path, EXTEND_CONFIG_FILEPATH);
+    if (!fs3.existsSync(configPath)) {
+      this.unlink();
+      return;
+    }
+    try {
+      const jsonConfig = JSON.parse(fs3.readFileSync(configPath, "utf-8"));
+      const config = configSchema.parse(jsonConfig);
+      const dependOnPath = fs3.realpathSync(path6.join(this.path, config.extends));
+      let dependOn = graph.get(dependOnPath);
+      if (!dependOn) {
+        dependOn = new _FilesMap(dependOnPath);
+        graph.set(dependOnPath, dependOn);
+        dependOn.update(graph, logger);
+      }
+      this.extend(dependOn);
+    } catch (error) {
+      logger.warn(`Failed to parse '${configPath}', content won't be included.
+Error: ${error}`);
+    }
+  }
+  extend(other) {
+    this.unlink();
+    other._dependents.add(this);
+    this._extend = other;
+  }
+  unlink() {
+    this._extend?._dependents.delete(this);
+    this._extend = null;
+  }
+  *allDependents() {
+    for (const dependency of this._dependents) {
+      yield dependency;
+      yield* dependency.allDependents();
+    }
+  }
+  async toFiles(logger) {
+    const filePathsObj = await this._toFilePathsCheckCycles({
+      logger,
+      visitedNodes: []
+    });
+    delete filePathsObj[EXTEND_CONFIG_FILEPATH];
+    const filePaths = Object.entries(filePathsObj);
+    filePaths.sort();
+    const files = {};
+    for (const [webcontainerPath2, filePath] of filePaths) {
+      const buffer = fs3.readFileSync(filePath);
+      try {
+        const stringContent = new TextDecoder("utf-8", { fatal: true }).decode(buffer);
+        files[webcontainerPath2] = stringContent;
+      } catch {
+        files[webcontainerPath2] = { base64: buffer.toString("base64") };
+      }
+    }
+    return files;
+  }
+  async _toFilePathsCheckCycles(context) {
+    const seenIndex = context.visitedNodes.indexOf(this.path);
+    if (seenIndex !== -1) {
+      context.logger.warn(
+        [
+          "Cycle detected:",
+          ...context.visitedNodes.map((filePath, index) => {
+            return `  * '${filePath}' ${index === seenIndex ? "<-- Cycle points back to that file" : ""}`;
+          }),
+          "Content will be ignored after that point."
+        ].join("\n")
+      );
+      return {};
+    }
+    context.visitedNodes.push(this.path);
+    const filePaths = this._extend ? await this._extend._toFilePathsCheckCycles(context) : {};
+    await getAllFiles(this.path, filePaths);
+    return filePaths;
+  }
+};
+async function getAllFiles(dir, result) {
+  const filePaths = await glob(`${glob.convertPathToPattern(dir)}/**/*`, {
+    onlyFiles: true,
+    dot: true,
+    ignore: IGNORED_FILES
+  });
+  for (const filePath of filePaths) {
+    result[webcontainerPath(dir, filePath)] = filePath;
+  }
+}
+function webcontainerPath(dir, filePath) {
+  const result = `/${path6.relative(dir, filePath)}`;
+  if (path6.sep !== "/") {
+    return result.replaceAll(path6.sep, "/");
+  }
+  return result;
+}
+
+// src/webcontainer-files/utils.ts
+import { folderPathToFilesRef } from "@tutorialkit-rb/types";
+import glob2 from "fast-glob";
+function getFilesRef(pathToFolder, { contentDir, templatesDir }) {
+  if (pathToFolder.startsWith(contentDir)) {
+    pathToFolder = pathToFolder.slice(contentDir.length + 1);
+  } else if (pathToFolder.startsWith(templatesDir)) {
+    pathToFolder = "template" + pathToFolder.slice(templatesDir.length);
+  }
+  return folderPathToFilesRef(pathToFolder);
+}
+function getAllFilesMap({ contentDir, templatesDir }) {
+  return glob2(
+    [
+      `${glob2.convertPathToPattern(contentDir)}/**/${FILES_FOLDER_NAME}`,
+      `${glob2.convertPathToPattern(contentDir)}/**/${SOLUTION_FOLDER_NAME}`,
+      `${glob2.convertPathToPattern(templatesDir)}/*`
+    ],
+    { onlyDirectories: true, ignore: IGNORED_FILES }
+  );
+}
+
+// src/webcontainer-files/cache.ts
+var FilesMapCache = class {
+  constructor(_filesMapGraph, _logger, _server, _dirs) {
+    this._filesMapGraph = _filesMapGraph;
+    this._logger = _logger;
+    this._server = _server;
+    this._dirs = _dirs;
+    const { promise, resolve } = withResolvers();
+    this._readiness = promise;
+    this._resolve = resolve;
+    for (const filesMap of _filesMapGraph.allFilesMap()) {
+      this._requestsQueue.add(filesMap.path);
+      this._cache.set(getFilesRef(filesMap.path, this._dirs), void 0);
+    }
+    this._generateFileMaps();
+  }
+  // map of filesRef to file content
+  _cache = /* @__PURE__ */ new Map();
+  // files that will be generated
+  _requestsQueue = /* @__PURE__ */ new Set();
+  // a promise to wait on before serving a request for the end user
+  _readiness;
+  _resolve;
+  // this is to know which FileMaps are in use to decide whether or not the page should be reloaded
+  _hotPaths = /* @__PURE__ */ new Set();
+  _timeoutId = null;
+  generateFileMapForPath(filePath) {
+    const filesMapFolderPath = resolveFilesFolderPath(filePath, this._logger, this._dirs);
+    if (!filesMapFolderPath) {
+      this._logger.warn(`File ${filePath} is not part of the tutorial content or templates folders.`);
+      return;
+    }
+    const filesRef = getFilesRef(filesMapFolderPath, this._dirs);
+    this._cache.set(filesRef, void 0);
+    this._invalidateCacheForDependencies(filesMapFolderPath);
+    this._requestsQueue.add(filesMapFolderPath);
+    if (this._timeoutId) {
+      return;
+    }
+    const { promise, resolve } = withResolvers();
+    this._readiness = promise;
+    this._resolve = resolve;
+    this._timeoutId = setTimeout(this._generateFileMaps, 100);
+  }
+  async canHandle(reqURL) {
+    const fileMapPath = new URL(reqURL ?? "/", "http://a").pathname.slice(1);
+    if (!this._cache.has(fileMapPath)) {
+      return false;
+    }
+    let cacheValue = this._cache.get(fileMapPath);
+    if (typeof cacheValue === "undefined") {
+      await this._readiness;
+      cacheValue = this._cache.get(fileMapPath);
+    }
+    if (typeof cacheValue === "undefined") {
+      this._logger.error(`The cache never resolved for ${fileMapPath}.`);
+      return false;
+    }
+    this._hotPaths.add(fileMapPath);
+    return cacheValue;
+  }
+  _invalidateCacheForDependencies(folderPath) {
+    const filesMap = this._filesMapGraph.getFilesMapByFolder(folderPath);
+    if (!filesMap) {
+      return;
+    }
+    for (const dependency of filesMap.allDependents()) {
+      this._cache.set(getFilesRef(dependency.path, this._dirs), void 0);
+    }
+  }
+  _generateFileMaps = async () => {
+    const hotFilesRefs = [];
+    while (this._requestsQueue.size > 0) {
+      for (const folderPath of this._requestsQueue) {
+        this._filesMapGraph.updateFilesMapByFolder(folderPath, this._logger);
+      }
+      for (const folderPath of this._requestsQueue) {
+        for (const dependency of this._filesMapGraph.getFilesMapByFolder(folderPath).allDependents()) {
+          this._requestsQueue.add(dependency.path);
+        }
+      }
+      const requests = [...this._requestsQueue].map((folderPath) => {
+        return [getFilesRef(folderPath, this._dirs), this._filesMapGraph.getFilesMapByFolder(folderPath)];
+      });
+      this._requestsQueue.clear();
+      await Promise.all(
+        requests.map(async ([filesRef, filesMap]) => {
+          if (this._hotPaths.has(filesRef)) {
+            hotFilesRefs.push(filesRef);
+          }
+          const timeNow = performance.now();
+          const fileMap = await filesMap.toFiles(this._logger);
+          this._cache.set(filesRef, JSON.stringify(fileMap));
+          const elapsed = performance.now() - timeNow;
+          this._logger.info(`Generated ${filesRef} ${dim(Math.round(elapsed) + "ms")}`);
+        })
+      );
+    }
+    this._resolve();
+    if (hotFilesRefs.length > 0) {
+      this._hotPaths.clear();
+      this._server.hot.send({ type: "custom", event: "tk:refresh-wc-files", data: hotFilesRefs });
+    }
+    this._timeoutId = null;
+  };
+};
+function resolveFilesFolderPath(filePath, logger, { contentDir, templatesDir }) {
+  if (filePath.startsWith(templatesDir)) {
+    const index = filePath.indexOf(path7.sep, templatesDir.length + 1);
+    if (index === -1) {
+      logger.error(`Bug: ${filePath} is not in a directory under ${templatesDir}`);
+      return void 0;
+    }
+    return filePath.slice(0, index);
+  }
+  if (filePath.startsWith(contentDir)) {
+    let filesFolder = filePath;
+    while (filesFolder && !filesFolder.endsWith(FILES_FOLDER_NAME) && !filesFolder.endsWith(SOLUTION_FOLDER_NAME)) {
+      if (filesFolder === contentDir) {
+        logger.error(`Bug: ${filePath} was not under ${FILES_FOLDER_NAME} or ${SOLUTION_FOLDER_NAME}`);
+        return void 0;
+      }
+      filesFolder = path7.dirname(filesFolder);
+    }
+    return filesFolder;
+  }
+  return void 0;
+}
+
+// src/webcontainer-files/index.ts
+var WebContainerFiles = class {
+  _watcher;
+  async serverSetup(projectRoot2, { server, logger }) {
+    const { contentDir, templatesDir } = this._folders(projectRoot2);
+    const graph = await FilesMap.initGraph(await getAllFilesMap({ contentDir, templatesDir }), logger);
+    const cache = new FilesMapCache(graph, logger, server, { contentDir, templatesDir });
+    this._watcher = watch2(
+      [
+        // TODO: does this work on Windows?
+        path8.join(contentDir, `**/${FILES_FOLDER_NAME}/**/*`),
+        path8.join(contentDir, `**/${SOLUTION_FOLDER_NAME}/**/*`),
+        templatesDir
+      ],
+      {
+        ignored: IGNORED_FILES,
+        ignoreInitial: true
+      }
+    );
+    this._watcher.on("all", (eventName, filePath) => {
+      if (eventName === "addDir") {
+        return;
+      }
+      cache.generateFileMapForPath(filePath);
+    });
+    server.middlewares.use(async (req, res, next) => {
+      const result = await cache.canHandle(req.url);
+      if (!result) {
+        next();
+        return;
+      }
+      res.writeHead(200, {
+        "Content-Type": "application/json"
+      });
+      res.end(result);
+    });
+  }
+  serverDone() {
+    return this._watcher?.close();
+  }
+  async buildAssets(projectRoot2, { dir, logger }) {
+    const { contentDir, templatesDir } = this._folders(projectRoot2);
+    const filesMapFolders = await getAllFilesMap({ contentDir, templatesDir });
+    const graph = await FilesMap.initGraph(filesMapFolders, logger);
+    await Promise.all(
+      filesMapFolders.map(async (folder) => {
+        folder = path8.normalize(folder);
+        const filesRef = getFilesRef(folder, { contentDir, templatesDir });
+        const dest = fileURLToPath3(new URL(filesRef, dir));
+        const fileMap = await graph.getFilesMapByFolder(folder).toFiles(logger);
+        await fs4.promises.writeFile(dest, JSON.stringify(fileMap));
+        logger.info(`${dim2(filesRef)}`);
+      })
+    );
+  }
+  _folders(projectRoot2) {
+    const contentDir = path8.join(projectRoot2, "./src/content/tutorial");
+    const templatesDir = path8.join(projectRoot2, "./src/templates");
+    return { contentDir, templatesDir };
+  }
+};
+
+// src/index.ts
+function createPlugin({
+  defaultRoutes = true,
+  components,
+  isolation,
+  enterprise,
+  expressiveCodePlugins = []
+} = {}) {
+  const webcontainerFiles = new WebContainerFiles();
+  let _config;
+  return {
+    name: "@tutorialkit-rb/astro",
+    hooks: {
+      async "astro:config:setup"(options) {
+        const { injectRoute, updateConfig, config } = options;
+        updateConfig({
+          server: {
+            headers: {
+              "Cross-Origin-Embedder-Policy": isolation ?? "require-corp",
+              "Cross-Origin-Opener-Policy": "same-origin"
+            }
+          },
+          vite: {
+            optimizeDeps: {
+              entries: ["!**/src/(content|templates)/**"],
+              include: null ? [] : [
+                "@tutorialkit-rb/react",
+                /**
+                 * The `picomatch` is CJS dependency used by `@tutorialkit-rb/runtime`.
+                 * When used via `@tutorialkit-rb/astro`, it's a transitive dependency that's
+                 * not automatically transformed.
+                 */
+                "@tutorialkit-rb/astro > picomatch/posix.js"
+              ]
+            },
+            define: {
+              __ENTERPRISE__: `${!!enterprise}`,
+              __WC_CONFIG__: enterprise ? JSON.stringify(enterprise) : "undefined"
+            },
+            ssr: {
+              noExternal: ["@tutorialkit-rb/astro", "@tutorialkit-rb/react"]
+            },
+            plugins: [
+              userlandCSS,
+              tutorialkitStore,
+              tutorialkitCore,
+              overrideComponents({ components, defaultRoutes: !!defaultRoutes }),
+              null ? (await null).default() : null
+            ]
+          }
+        });
+        updateMarkdownConfig(options);
+        if (defaultRoutes) {
+          if (defaultRoutes !== "tutorial-only") {
+            injectRoute({
+              pattern: "/",
+              entrypoint: "@tutorialkit-rb/astro/default/pages/index.astro",
+              prerender: true
+            });
+          }
+          injectRoute({
+            pattern: "[...slug]",
+            entrypoint: "@tutorialkit-rb/astro/default/pages/[...slug].astro",
+            prerender: true
+          });
+        }
+        const selfIndex = config.integrations.findIndex((integration) => integration.name === "@tutorialkit-rb/astro");
+        config.integrations.splice(
+          selfIndex + 1,
+          0,
+          ...extraIntegrations({ root: fileURLToPath4(config.root), expressiveCodePlugins })
+        );
+      },
+      "astro:config:done"({ config }) {
+        _config = config;
+      },
+      async "astro:server:setup"(options) {
+        if (!_config) {
+          return;
+        }
+        const { server, logger } = options;
+        const projectRoot2 = fileURLToPath4(_config.root);
+        await webcontainerFiles.serverSetup(projectRoot2, options);
+        watchUserlandCSS(server, logger);
+      },
+      async "astro:server:done"() {
+        await webcontainerFiles.serverDone();
+      },
+      async "astro:build:done"(astroBuildDoneOptions) {
+        const projectRoot2 = fileURLToPath4(_config.root);
+        await webcontainerFiles.buildAssets(projectRoot2, astroBuildDoneOptions);
+      }
+    }
+  };
+}
+export {
+  createPlugin as default
+};