@tutorialkit/astro/dist/index.js

// 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 expressiveCode from "astro-expressive-code";
import UnoCSS from "unocss/astro";
import { getInlineContentForPackage } from "@tutorialkit/theme";
function extraIntegrations({ root }) {
  return [
    react(),
    expressiveCode({
      plugins: [pluginCollapsibleSections(), pluginLineNumbers()],
      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/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 frontMatter from "front-matter";
import * as kleur from "kleur/colors";
import fs from "node:fs";
import path from "node:path";
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.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 { watch } from "chokidar";
import fs2 from "fs/promises";
import path4 from "path";
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/store.ts
import path5 from "node:path";
import { fileURLToPath as fileURLToPath2 } from "node:url";
var __dirname2 = path5.dirname(fileURLToPath2(import.meta.url));
var virtualModuleId3 = "tutorialkit:store";
var resolvedVirtualModuleId3 = `${virtualModuleId3}`;
var tutorialkitStore = {
  name: "tutorialkit-store-virtual-mod-plugin",
  resolveId(id) {
    if (id === virtualModuleId3) {
      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/vite-plugins/override-components.ts
var virtualModuleId4 = "tutorialkit:override-components";
var resolvedId = `\0${virtualModuleId4}`;
function overrideComponents({ components, defaultRoutes }) {
  return {
    name: "tutorialkit-override-components-plugin",
    resolveId(id) {
      if (id === virtualModuleId4) {
        return resolvedId;
      }
      return void 0;
    },
    async load(id) {
      if (id === resolvedId) {
        const topBar = components?.TopBar || resolveDefaultTopBar(defaultRoutes);
        return `
          export { default as TopBar } from '${topBar}';
        `;
      }
      return void 0;
    }
  };
}
function resolveDefaultTopBar(defaultRoutes) {
  if (defaultRoutes) {
    return "@tutorialkit/astro/default/components/TopBar.astro";
  }
  return "./src/components/TopBar.astro";
}

// src/webcontainer-files/index.ts
import { watch as watch2 } from "chokidar";
import { dim as dim2 } from "kleur/colors";
import fs4 from "node:fs";
import path8 from "node:path";
import { fileURLToPath as fileURLToPath3 } from "node:url";

// src/webcontainer-files/cache.ts
import { dim } from "kleur/colors";
import path7 from "node:path";

// 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 glob from "fast-glob";
import fs3 from "node:fs";
import path6 from "node:path";
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/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
} = {}) {
  const webcontainerFiles = new WebContainerFiles();
  let _config;
  return {
    name: "@tutorialkit/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/react"]
            },
            define: {
              __ENTERPRISE__: `${!!enterprise}`,
              __WC_CONFIG__: enterprise ? JSON.stringify(enterprise) : "undefined"
            },
            ssr: {
              noExternal: ["@tutorialkit/astro", "@tutorialkit/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/astro/default/pages/index.astro",
              prerender: true
            });
          }
          injectRoute({
            pattern: "[...slug]",
            entrypoint: "@tutorialkit/astro/default/pages/[...slug].astro",
            prerender: true
          });
        }
        const selfIndex = config.integrations.findIndex((integration) => integration.name === "@tutorialkit/astro");
        config.integrations.splice(selfIndex + 1, 0, ...extraIntegrations({ root: fileURLToPath4(config.root) }));
      },
      "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
};