remark-sandpack/dist/index.cjs

Use sandpack in MDX

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
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);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  remarkSandpack: () => transform
});
module.exports = __toCommonJS(src_exports);

// src/node.ts
var import_console = require("console");
var import_fs = require("fs");
var import_fs_readdir_recursive = __toESM(require("fs-readdir-recursive"), 1);
var import_path = require("path");

// src/utils.ts
var isFilename = (str) => {
  return /[\w]+\.[\w]+/.test(str);
};

// src/node.ts
var transformCode = async (jsxNode, file) => {
  const files = {};
  const visit = await import("unist-util-visit").then((module2) => module2.visit);
  visit(jsxNode, "code", (codeNode) => {
    var _a;
    const meta = resolveCodeMeta(codeNode);
    let code = codeNode.value;
    if (meta.dir) {
      const dir = (0, import_path.join)(process.cwd(), meta.dir);
      (0, import_console.assert)((0, import_fs.existsSync)(dir));
      const dirFiles = (0, import_fs_readdir_recursive.default)(dir);
      dirFiles.forEach((path) => {
        const file2 = files[path] || {};
        files[path] = __spreadProps(__spreadValues({}, file2), { code: (0, import_fs.readFileSync)((0, import_path.join)(dir, path), "utf8") });
      });
    } else if (meta.file) {
      const filePath = (0, import_path.join)(file.cwd, meta.file);
      if ((0, import_fs.existsSync)(filePath)) {
        code = (0, import_fs.readFileSync)(filePath, "utf8");
        meta.name || (meta.name = (0, import_path.basename)(filePath));
      }
    }
    if (meta.name) {
      let rawCode = "";
      rawCode = (_a = files[meta.name]) == null ? void 0 : _a.code;
      files[meta.name] = {
        code: code || rawCode || "",
        active: meta.active,
        hidden: meta.hidden,
        readOnly: meta.readOnly
      };
    }
  });
  await appendProp(jsxNode, "files", files);
};
var resolveCodeMeta = (codeNode) => {
  const joinedMeta = codeNode.lang + " " + (codeNode.meta || "");
  return joinedMeta.split(" ").filter((meta) => meta.length).reduce((meta, expression) => {
    const [key, value] = expression.split("=");
    if (!value && isFilename(key)) {
      meta.name = key;
    } else {
      meta[key] = value || true;
    }
    return meta;
  }, {});
};
var appendProp = async (node, propName, propValue) => {
  const valueToEstree = await import("estree-util-value-to-estree").then((module2) => module2.valueToEstree);
  node.attributes.push({
    type: "mdxJsxAttribute",
    name: propName,
    value: {
      type: "mdxJsxAttributeValueExpression",
      value: JSON.stringify(propValue),
      data: {
        estree: {
          type: "Program",
          body: [
            {
              type: "ExpressionStatement",
              expression: valueToEstree(propValue)
            }
          ],
          sourceType: "module"
        }
      }
    }
  });
};

// src/transform.ts
var transform = (options) => {
  const componentName = Array.isArray(options == null ? void 0 : options.componentName) ? options == null ? void 0 : options.componentName : [(options == null ? void 0 : options.componentName) || "Sandpack"];
  return async (tree, file) => {
    const visit = await import("unist-util-visit").then((module2) => module2.visit);
    const promises = [];
    visit(tree, "mdxJsxFlowElement", (jsxNode) => {
      if (!componentName.includes(jsxNode.name)) return;
      promises.push(async () => transformCode(jsxNode, file));
    });
    await Promise.all(promises.map((p) => p()));
  };
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  remarkSandpack
});