@studiocms/ui/dist/utils/integration-utils.js

The UI library for StudioCMS. Includes the layouts & components we use to build StudioCMS.

import { fileURLToPath } from "node:url";
import { AstroError } from "astro/errors";
import { dirname, resolve } from "pathe";
const createResolver = (_base) => {
  let base = _base;
  if (base.startsWith("file://")) {
    base = dirname(fileURLToPath(base));
  }
  return {
    resolve: (...path) => resolve(base, ...path)
  };
};
const defineUtility = (_hook) => (
  /**
   * The function itself
   * @param {Function} fn;
   */
  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
  (fn) => fn
);
function getPluginNames(plugins) {
  const names = [];
  if (plugins) {
    for (const plugin of plugins) {
      if (!plugin) continue;
      if (Array.isArray(plugin)) {
        names.push(...getPluginNames(plugin));
        continue;
      }
      if (plugin instanceof Promise) {
        continue;
      }
      names.push(plugin.name);
    }
  }
  return names;
}
const hasVitePlugin = defineUtility("astro:config:setup")(
  ({ config }, {
    plugin
  }) => {
    if (!plugin || plugin instanceof Promise) return false;
    const currentPlugins = new Set(getPluginNames(config?.vite?.plugins));
    const plugins = /* @__PURE__ */ new Set();
    if (typeof plugin === "string") {
      plugins.add(plugin);
    }
    if (typeof plugin === "object") {
      if (Array.isArray(plugin)) {
        const names = new Set(
          getPluginNames(plugin)
        );
        for (const name of names) plugins.add(name);
      } else {
        plugins.add(plugin.name);
      }
    }
    return [...plugins].some((name) => currentPlugins.has(name));
  }
);
const addVitePlugin = defineUtility("astro:config:setup")(
  (params, {
    plugin,
    warnDuplicated = true
  }) => {
    const { updateConfig, logger } = params;
    if (warnDuplicated && hasVitePlugin(params, { plugin })) {
      logger.warn(
        `The Vite plugin "${plugin.name}" is already present in your Vite configuration, this plugin may not behave correctly.`
      );
    }
    updateConfig({
      vite: {
        plugins: [plugin]
      }
    });
  }
);
const incrementPluginName = (name) => {
  let count = 1;
  return `${name.replace(/-(\d+)$/, (_, c) => {
    count = Number.parseInt(c) + 1;
    return "";
  })}-${count}`;
};
const resolveVirtualModuleId = (id) => {
  return `\0${id}`;
};
const createVirtualModule = (name, _imports, bypassCoreValidation) => {
  const imports = Array.isArray(_imports) ? _imports : Object.entries(_imports).map(([id, content]) => ({
    id,
    content,
    context: void 0
  }));
  const duplicatedImports = {};
  for (const { id, context } of imports) {
    duplicatedImports[id] ??= [];
    duplicatedImports[id]?.push(...context === void 0 ? ["server", "client"] : [context]);
  }
  for (const [id, contexts] of Object.entries(duplicatedImports)) {
    if (contexts.length !== [...new Set(contexts)].length) {
      throw new AstroError(
        `Virtual import with id "${id}" has been registered several times with conflicting contexts.`
      );
    }
  }
  const resolutionMap = Object.fromEntries(
    imports.map(({ id }) => {
      if (!bypassCoreValidation && id.startsWith("astro:")) {
        throw new AstroError(
          `Virtual import name prefix can't be "astro:" (for "${id}") because it's reserved for Astro core.`
        );
      }
      return [resolveVirtualModuleId(id), id];
    })
  );
  return {
    name,
    resolveId(id) {
      if (imports.find((_import) => _import.id === id)) {
        return resolveVirtualModuleId(id);
      }
      return;
    },
    load(id, options) {
      const resolution = resolutionMap[id];
      if (resolution) {
        const context = options?.ssr ? "server" : "client";
        const data = imports.find(
          (_import) => _import.id === resolution && (_import.context === void 0 || _import.context === context)
        );
        if (data) {
          return data.content;
        }
      }
      return;
    }
  };
};
const addVirtualImports = defineUtility("astro:config:setup")(
  (params, {
    name,
    imports,
    __enableCorePowerDoNotUseOrYouWillBeFired = false
  }) => {
    let pluginName = `vite-plugin-${name}`;
    while (hasVitePlugin(params, { plugin: pluginName }))
      pluginName = incrementPluginName(pluginName);
    addVitePlugin(params, {
      warnDuplicated: false,
      plugin: createVirtualModule(pluginName, imports, __enableCorePowerDoNotUseOrYouWillBeFired)
    });
  }
);
export {
  addVirtualImports,
  addVitePlugin,
  createResolver,
  defineUtility,
  hasVitePlugin
};