@dtwo/kit 3.0.0-rc.13

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 - Dtwo Project
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# Dtwo Kit
+
+> Toolkit for authoring Dtwo Modules

package/dist/index.d.ts

@@ -0,0 +1,333 @@
+import { ModuleOptions, ModuleDefinition, DtwoModule, Dtwo, DtwoConfig, DtwoOptions, ImportPresetWithDeprecation, DtwoCompatibility, DtwoCompatibilityIssues, ComponentsDir, Component, DtwoTemplate, DtwoHooks, DtwoPlugin, DtwoPluginTemplate, ResolvedDtwoTemplate } from '@dtwo/schema';
+import { LoadConfigOptions } from 'c12';
+import { Import } from 'unimport';
+import { Configuration, WebpackPluginInstance } from 'webpack';
+import { UserConfig, Plugin } from 'wite';
+import * as unctx_index from 'unctx/index';
+import { HoleEventHandler, HoleDevEventHandler, Hole } from 'holepack';
+import * as consola from 'consola';
+import { genSafeVariableName } from 'knitwork';
+
+/**
+ * Define a Dtwo module, automatically merging defaults with user provided options, installing
+ * any hooks that are provided, and calling an optional setup function for full control.
+ */
+declare function defineDtwoModule<OptionsT extends ModuleOptions>(definition: ModuleDefinition<OptionsT>): DtwoModule<OptionsT>;
+
+/** Installs a module on a Dtwo instance. */
+declare function installModule(moduleToInstall: string | DtwoModule, _inlineOptions?: any, _dtwo?: Dtwo): Promise<void>;
+
+interface LoadDtwoConfigOptions extends LoadConfigOptions<DtwoConfig> {
+}
+declare function loadDtwoConfig(opts: LoadDtwoConfigOptions): Promise<DtwoOptions>;
+
+interface LoadDtwoOptions extends LoadDtwoConfigOptions {
+    /** Load dtwo with development mode */
+    dev?: boolean;
+    /** Use lazy initialization of dtwo if set to false */
+    ready?: boolean;
+    /** @deprecated Use cwd option */
+    rootDir?: LoadDtwoConfigOptions['cwd'];
+    /** @deprecated use overrides option */
+    config?: LoadDtwoConfigOptions['overrides'];
+}
+declare function loadDtwo(opts: LoadDtwoOptions): Promise<Dtwo>;
+declare function buildDtwo(dtwo: Dtwo): Promise<any>;
+
+declare function addImports(imports: Import | Import[]): void;
+declare function addImportsDir(dirs: string | string[]): void;
+declare function addImportsSources(presets: ImportPresetWithDeprecation | ImportPresetWithDeprecation[]): void;
+
+interface ExtendConfigOptions {
+    /**
+     * Install plugin on dev
+     *
+     * @default true
+     */
+    dev?: boolean;
+    /**
+     * Install plugin on build
+     *
+     * @default true
+     */
+    build?: boolean;
+    /**
+     * Install plugin on server side
+     *
+     * @default true
+     */
+    server?: boolean;
+    /**
+     * Install plugin on client side
+     *
+     * @default true
+     */
+    client?: boolean;
+}
+interface ExtendWebpackConfigOptions extends ExtendConfigOptions {
+}
+interface ExtendWiteConfigOptions extends ExtendConfigOptions {
+}
+/**
+ * Extend Webpack config
+ *
+ * The fallback function might be called multiple times
+ * when applying to both client and server builds.
+ */
+declare function extendWebpackConfig(fn: ((config: Configuration) => void), options?: ExtendWebpackConfigOptions): void;
+/**
+ * Extend Wite config
+ */
+declare function extendWiteConfig(fn: ((config: UserConfig) => void), options?: ExtendWiteConfigOptions): (() => void) | undefined;
+/**
+ * Append Webpack plugin to the config.
+ */
+declare function addWebpackPlugin(plugin: WebpackPluginInstance | WebpackPluginInstance[], options?: ExtendWebpackConfigOptions): void;
+/**
+ * Append Wite plugin to the config.
+ */
+declare function addWitePlugin(plugin: Plugin | Plugin[], options?: ExtendWiteConfigOptions): void;
+
+/**
+ * Check version constraints and return incompatibility issues as an array
+ */
+declare function checkDtwoCompatibility(constraints: DtwoCompatibility, dtwo?: Dtwo): Promise<DtwoCompatibilityIssues>;
+/**
+ * Check version constraints and throw a detailed error if has any, otherwise returns true
+ */
+declare function assertDtwoCompatibility(constraints: DtwoCompatibility, dtwo?: Dtwo): Promise<true>;
+/**
+ * Check version constraints and return true if passed, otherwise returns false
+ */
+declare function hasDtwoCompatibility(constraints: DtwoCompatibility, dtwo?: Dtwo): Promise<boolean>;
+/**
+ * Check if current dtwo instance is version 2 legacy
+ */
+declare function isDtwo2(dtwo?: Dtwo): any;
+/**
+ * Check if current dtwo instance is version 3
+ */
+declare function isDtwo3(dtwo?: Dtwo): any;
+/**
+ * Get dtwo version
+ */
+declare function getDtwoVersion(dtwo?: Dtwo | any): any;
+
+/**
+ * Register a directory to be scanned for components and imported only when used.
+ *
+ * Requires Dtwo 2.13+
+ */
+declare function addComponentsDir(dir: ComponentsDir): Promise<void>;
+type AddComponentOptions = {
+    name: string;
+    filePath: string;
+} & Partial<Exclude<Component, 'shortPath' | 'async' | 'level' | 'import' | 'asyncImport'>>;
+/**
+ * Register a directory to be scanned for components and imported only when used.
+ *
+ * Requires Dtwo 2.13+
+ */
+declare function addComponent(opts: AddComponentOptions): Promise<void>;
+
+/** Direct access to the Dtwo context - see https://github.com/unjs/unctx. */
+declare const dtwoCtx: unctx_index.UseContext<Dtwo>;
+/**
+ * Get access to Dtwo instance.
+ *
+ * Throws an error if Dtwo instance is unavailable.
+ *
+ * @example
+ * ```js
+ * const dtwo = useDtwo()
+ * ```
+ */
+declare function useDtwo(): Dtwo;
+/**
+ * Get access to Dtwo instance.
+ *
+ * Returns null if Dtwo instance is unavailable.
+ *
+ * @example
+ * ```js
+ * const dtwo = tryUseDtwo()
+ * if (dtwo) {
+ *  // Do something
+ * }
+ * ```
+ */
+declare function tryUseDtwo(): Dtwo | null;
+
+/**
+ * Adds a hole server handler
+ *
+ */
+declare function addServerHandler(handler: HoleEventHandler): void;
+/**
+ * Adds a hole server handler for development-only
+ *
+ */
+declare function addDevServerHandler(handler: HoleDevEventHandler): void;
+/**
+ * Adds a Hole plugin
+ */
+declare function addServerPlugin(plugin: string): void;
+/**
+ * Adds routes to be prerendered
+ */
+declare function addPrerenderRoutes(routes: string | string[]): void;
+/**
+ * Access to the Hole instance
+ *
+ * **Note:** You can call `useHole()` only after `ready` hook.
+ *
+ * **Note:** Changes to the Hole instance configuration are not applied.
+ *
+ * @example
+ *
+ * ```ts
+ * dtwo.hook('ready', () => {
+ *   console.log(useHole())
+ * })
+ * ```
+ */
+declare function useHole(): Hole;
+
+/**
+ * Return a filter function to filter an array of paths
+ */
+declare function isIgnored(pathname: string): boolean;
+
+declare function addLayout(this: any, template: DtwoTemplate, name?: string): void;
+
+declare function extendPages(cb: DtwoHooks['pages:extend']): void;
+
+/**
+ * Normalize a dtwo plugin object
+ */
+declare function normalizePlugin(plugin: DtwoPlugin | string): DtwoPlugin;
+/**
+ * Registers a dtwo plugin and to the plugins array.
+ *
+ * Note: You can use mode or .client and .server modifiers with fileName option
+ * to use plugin only in client or server side.
+ *
+ * Note: By default plugin is prepended to the plugins array. You can use second argument to append (push) instead.
+ *
+ * @example
+ * ```js
+ * addPlugin({
+ *   src: path.resolve(__dirname, 'templates/foo.js'),
+ *   filename: 'foo.server.js' // [optional] only include in server bundle
+ * })
+ * ```
+ */
+interface AddPluginOptions {
+    append?: boolean;
+}
+declare function addPlugin(_plugin: DtwoPlugin | string, opts?: AddPluginOptions): DtwoPlugin;
+/**
+ * Adds a template and registers as a dtwo plugin.
+ */
+declare function addPluginTemplate(plugin: DtwoPluginTemplate | string, opts?: AddPluginOptions): DtwoPlugin;
+
+interface ResolvePathOptions {
+    /** Base for resolving paths from. Default is Dtwo rootDir. */
+    cwd?: string;
+    /** An object of aliases. Default is Dtwo configured aliases. */
+    alias?: Record<string, string>;
+    /** The file extensions to try. Default is Dtwo configured extensions. */
+    extensions?: string[];
+}
+/**
+ * Resolve full path to a file or directory respecting Dtwo alias and extensions options
+ *
+ * If path could not be resolved, normalized input path will be returned
+ */
+declare function resolvePath(path: string, opts?: ResolvePathOptions): Promise<string>;
+/**
+ * Try to resolve first existing file in paths
+ */
+declare function findPath(paths: string | string[], opts?: ResolvePathOptions, pathType?: 'file' | 'dir'): Promise<string | null>;
+/**
+ * Resolve path aliases respecting Dtwo alias options
+ */
+declare function resolveAlias(path: string, alias?: Record<string, string>): string;
+interface Resolver {
+    resolve(...path: string[]): string;
+    resolvePath(path: string, opts?: ResolvePathOptions): Promise<string>;
+}
+/**
+ * Create a relative resolver
+ */
+declare function createResolver(base: string | URL): Resolver;
+declare function resolveFiles(path: string, pattern: string | string[], opts?: {
+    followSymbolicLinks?: boolean;
+}): Promise<string[]>;
+
+/**
+ * Renders given template using lodash template during build into the project buildDir
+ */
+declare function addTemplate(_template: DtwoTemplate<any> | string): ResolvedDtwoTemplate<any>;
+/**
+ * Normalize a dtwo template object
+ */
+declare function normalizeTemplate(template: DtwoTemplate<any> | string): ResolvedDtwoTemplate<any>;
+/**
+ * Trigger rebuilding Dtwo templates
+ *
+ * You can pass a filter within the options to selectively regenerate a subset of templates.
+ */
+declare function updateTemplates(options?: {
+    filter?: (template: ResolvedDtwoTemplate<any>) => boolean;
+}): Promise<any>;
+
+declare const logger: consola.Consola;
+declare function useLogger(scope?: string): consola.Consola;
+
+/** @deprecated Do not use CJS utils */
+interface ResolveModuleOptions {
+    paths?: string | string[];
+}
+/** @deprecated Do not use CJS utils */
+interface RequireModuleOptions extends ResolveModuleOptions {
+    /** Clear the require cache (force fresh require) but only if not within `node_modules` */
+    clearCache?: boolean;
+    /** Automatically de-default the result of requiring the module. */
+    interopDefault?: boolean;
+}
+/** @deprecated Do not use CJS utils */
+declare function isNodeModules(id: string): boolean;
+/** @deprecated Do not use CJS utils */
+declare function clearRequireCache(id: string): void;
+/** @deprecated Do not use CJS utils */
+declare function scanRequireTree(id: string, files?: Set<string>): Set<string>;
+/** @deprecated Do not use CJS utils */
+declare function getRequireCacheItem(id: string): NodeModule | undefined;
+/** Resolve the `package.json` file for a given module. */
+declare function requireModulePkg(id: string, opts?: RequireModuleOptions): any;
+/** @deprecated Do not use CJS utils */
+declare function resolveModule(id: string, opts?: ResolveModuleOptions): string;
+/** @deprecated Do not use CJS utils */
+declare function tryResolveModule(path: string, opts?: ResolveModuleOptions): string | null;
+/** @deprecated Do not use CJS utils */
+declare function requireModule(id: string, opts?: RequireModuleOptions): any;
+/** @deprecated Do not use CJS utils */
+declare function importModule(id: string, opts?: RequireModuleOptions): Promise<any>;
+/** @deprecated Do not use CJS utils */
+declare function tryImportModule(id: string, opts?: RequireModuleOptions): Promise<any> | undefined;
+/** @deprecated Do not use CJS utils */
+declare function tryRequireModule(id: string, opts?: RequireModuleOptions): any;
+
+/** @deprecated */
+declare function compileTemplate(template: DtwoTemplate, ctx: any): Promise<string>;
+/** @deprecated */
+declare const templateUtils: {
+    serialize: (data: any) => string;
+    importName: typeof genSafeVariableName;
+    importSources: (sources: string | string[], { lazy }?: {
+        lazy?: boolean | undefined;
+    }) => string;
+};
+
+export { AddComponentOptions, AddPluginOptions, ExtendConfigOptions, ExtendWebpackConfigOptions, ExtendWiteConfigOptions, LoadDtwoConfigOptions, LoadDtwoOptions, RequireModuleOptions, ResolveModuleOptions, ResolvePathOptions, Resolver, addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addServerHandler, addServerPlugin, addTemplate, addWebpackPlugin, addWitePlugin, assertDtwoCompatibility, buildDtwo, checkDtwoCompatibility, clearRequireCache, compileTemplate, createResolver, defineDtwoModule, dtwoCtx, extendPages, extendWebpackConfig, extendWiteConfig, findPath, getDtwoVersion, getRequireCacheItem, hasDtwoCompatibility, importModule, installModule, isDtwo2, isDtwo3, isIgnored, isNodeModules, loadDtwo, loadDtwoConfig, logger, normalizePlugin, normalizeTemplate, requireModule, requireModulePkg, resolveAlias, resolveFiles, resolveModule, resolvePath, scanRequireTree, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseDtwo, updateTemplates, useDtwo, useHole, useLogger };

package/dist/index.mjs

@@ -0,0 +1,796 @@
+import { promises, existsSync, readFileSync } from 'node:fs';
+import defu from 'defu';
+import { applyDefaults } from 'untyped';
+import { dirname, join, normalize, relative, isAbsolute, resolve, basename, parse } from 'pathe';
+import consola from 'consola';
+import { getContext } from 'unctx';
+import satisfies from 'semver/functions/satisfies.js';
+import lodashTemplate from 'lodash.template';
+import { genSafeVariableName, genDynamicImport, genImport } from 'knitwork';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { interopDefault } from 'mlly';
+import jiti from 'jiti';
+import { globby } from 'globby';
+import { resolveAlias as resolveAlias$1 } from 'pathe/utils';
+import ignore from 'ignore';
+import { loadConfig } from 'c12';
+import { DtwoConfigSchema } from '@dtwo/schema';
+import { resolvePackageJSON, readPackageJSON } from 'pkg-types';
+import { kebabCase, pascalCase } from 'scule';
+import hash from 'hash-sum';
+
+const logger = consola;
+function useLogger(scope) {
+  return scope ? logger.withScope(scope) : logger;
+}
+
+const dtwoCtx = getContext("dtwo");
+function useDtwo() {
+  const instance = dtwoCtx.tryUse();
+  if (!instance) {
+    throw new Error("Dtwo instance is unavailable!");
+  }
+  return instance;
+}
+function tryUseDtwo() {
+  return dtwoCtx.tryUse();
+}
+
+async function checkDtwoCompatibility(constraints, dtwo = useDtwo()) {
+  const issues = [];
+  if (constraints.dtwo) {
+    const dtwoVersion = getDtwoVersion(dtwo);
+    const dtwoSemanticVersion = dtwoVersion.replace(/-[0-9]+\.[0-9a-f]{7,8}/, "");
+    if (!satisfies(dtwoSemanticVersion, constraints.dtwo, { includePrerelease: true })) {
+      issues.push({
+        name: "dtwo",
+        message: `Dtwo version \`${constraints.dtwo}\` is required but currently using \`${dtwoVersion}\``
+      });
+    }
+  }
+  if (isDtwo2(dtwo)) {
+    const bridgeRequirement = constraints.bridge;
+    const hasBridge = !!dtwo.options.bridge;
+    if (bridgeRequirement === true && !hasBridge) {
+      issues.push({
+        name: "bridge",
+        message: "Dtwo bridge is required"
+      });
+    } else if (bridgeRequirement === false && hasBridge) {
+      issues.push({
+        name: "bridge",
+        message: "Dtwo bridge is not supported"
+      });
+    }
+  }
+  await dtwo.callHook("kit:compatibility", constraints, issues);
+  issues.toString = () => issues.map((issue) => ` - [${issue.name}] ${issue.message}`).join("\n");
+  return issues;
+}
+async function assertDtwoCompatibility(constraints, dtwo = useDtwo()) {
+  const issues = await checkDtwoCompatibility(constraints, dtwo);
+  if (issues.length) {
+    throw new Error("Dtwo compatibility issues found:\n" + issues.toString());
+  }
+  return true;
+}
+async function hasDtwoCompatibility(constraints, dtwo = useDtwo()) {
+  const issues = await checkDtwoCompatibility(constraints, dtwo);
+  return !issues.length;
+}
+function isDtwo2(dtwo = useDtwo()) {
+  return getDtwoVersion(dtwo).startsWith("2.");
+}
+function isDtwo3(dtwo = useDtwo()) {
+  return getDtwoVersion(dtwo).startsWith("3.");
+}
+function getDtwoVersion(dtwo = useDtwo()) {
+  const version = (dtwo?._version || dtwo?.version || dtwo?.constructor?.version || "").replace(/^v/g, "");
+  if (!version) {
+    throw new Error("Cannot determine dtwo version! Is current instance passed?");
+  }
+  return version;
+}
+
+async function compileTemplate(template, ctx) {
+  const data = { ...ctx, options: template.options };
+  if (template.src) {
+    try {
+      const srcContents = await promises.readFile(template.src, "utf-8");
+      return lodashTemplate(srcContents, {})(data);
+    } catch (err) {
+      console.error("Error compiling template: ", template);
+      throw err;
+    }
+  }
+  if (template.getContents) {
+    return template.getContents(data);
+  }
+  throw new Error("Invalid template: " + JSON.stringify(template));
+}
+const serialize = (data) => JSON.stringify(data, null, 2).replace(/"{(.+)}"(?=,?$)/gm, (r) => JSON.parse(r).replace(/^{(.*)}$/, "$1"));
+const importSources = (sources, { lazy = false } = {}) => {
+  if (!Array.isArray(sources)) {
+    sources = [sources];
+  }
+  return sources.map((src) => {
+    if (lazy) {
+      return `const ${genSafeVariableName(src)} = ${genDynamicImport(src, { comment: `webpackChunkName: ${JSON.stringify(src)}` })}`;
+    }
+    return genImport(src, genSafeVariableName(src));
+  }).join("\n");
+};
+const importName = genSafeVariableName;
+const templateUtils = { serialize, importName, importSources };
+
+function defineDtwoModule(definition) {
+  if (!definition.meta) {
+    definition.meta = {};
+  }
+  if (definition.meta.configKey === void 0) {
+    definition.meta.configKey = definition.meta.name;
+  }
+  async function getOptions(inlineOptions, dtwo = useDtwo()) {
+    const configKey = definition.meta.configKey || definition.meta.name;
+    const _defaults = definition.defaults instanceof Function ? definition.defaults(dtwo) : definition.defaults;
+    let _options = defu(inlineOptions, dtwo.options[configKey], _defaults);
+    if (definition.schema) {
+      _options = await applyDefaults(definition.schema, _options);
+    }
+    return Promise.resolve(_options);
+  }
+  async function normalizedModule(inlineOptions, dtwo) {
+    if (!dtwo) {
+      dtwo = tryUseDtwo() || this.dtwo;
+    }
+    const uniqueKey = definition.meta.name || definition.meta.configKey;
+    if (uniqueKey) {
+      dtwo.options._requiredModules = dtwo.options._requiredModules || {};
+      if (dtwo.options._requiredModules[uniqueKey]) {
+        return;
+      }
+      dtwo.options._requiredModules[uniqueKey] = true;
+    }
+    if (definition.meta.compatibility) {
+      const issues = await checkDtwoCompatibility(definition.meta.compatibility, dtwo);
+      if (issues.length) {
+        logger.warn(`Module \`${definition.meta.name}\` is disabled due to incompatibility issues:
+${issues.toString()}`);
+        return;
+      }
+    }
+    dtwo2Shims(dtwo);
+    const _options = await getOptions(inlineOptions, dtwo);
+    if (definition.hooks) {
+      dtwo.hooks.addHooks(definition.hooks);
+    }
+    await definition.setup?.call(null, _options, dtwo);
+  }
+  normalizedModule.getMeta = () => Promise.resolve(definition.meta);
+  normalizedModule.getOptions = getOptions;
+  return normalizedModule;
+}
+const DTWO2_SHIMS_KEY = "__dtwo2_shims_key__";
+function dtwo2Shims(dtwo) {
+  if (!isDtwo2(dtwo) || dtwo[DTWO2_SHIMS_KEY]) {
+    return;
+  }
+  dtwo[DTWO2_SHIMS_KEY] = true;
+  dtwo.hooks = dtwo;
+  if (!dtwoCtx.tryUse()) {
+    dtwoCtx.set(dtwo);
+    dtwo.hook("close", () => dtwoCtx.unset());
+  }
+  let virtualTemplates;
+  dtwo.hook("builder:prepared", (_builder, buildOptions) => {
+    virtualTemplates = buildOptions.templates.filter((t) => t.getContents);
+    for (const template of virtualTemplates) {
+      buildOptions.templates.splice(buildOptions.templates.indexOf(template), 1);
+    }
+  });
+  dtwo.hook("build:templates", async (templates) => {
+    const context = {
+      dtwo,
+      utils: templateUtils,
+      app: {
+        dir: dtwo.options.srcDir,
+        extensions: dtwo.options.extensions,
+        plugins: dtwo.options.plugins,
+        templates: [
+          ...templates.templatesFiles,
+          ...virtualTemplates
+        ],
+        templateVars: templates.templateVars
+      }
+    };
+    for await (const template of virtualTemplates) {
+      const contents = await compileTemplate({ ...template, src: "" }, context);
+      await promises.mkdir(dirname(template.dst), { recursive: true });
+      await promises.writeFile(template.dst, contents);
+    }
+  });
+}
+
+const _require = jiti(process.cwd(), { interopDefault: true, esmResolve: true });
+function isNodeModules(id) {
+  return /[/\\]node_modules[/\\]/.test(id);
+}
+function clearRequireCache(id) {
+  if (isNodeModules(id)) {
+    return;
+  }
+  const entry = getRequireCacheItem(id);
+  if (!entry) {
+    delete _require.cache[id];
+    return;
+  }
+  if (entry.parent) {
+    entry.parent.children = entry.parent.children.filter((e) => e.id !== id);
+  }
+  for (const child of entry.children) {
+    clearRequireCache(child.id);
+  }
+  delete _require.cache[id];
+}
+function scanRequireTree(id, files = /* @__PURE__ */ new Set()) {
+  if (isNodeModules(id) || files.has(id)) {
+    return files;
+  }
+  const entry = getRequireCacheItem(id);
+  if (!entry) {
+    files.add(id);
+    return files;
+  }
+  files.add(entry.id);
+  for (const child of entry.children) {
+    scanRequireTree(child.id, files);
+  }
+  return files;
+}
+function getRequireCacheItem(id) {
+  try {
+    return _require.cache[id];
+  } catch (e) {
+  }
+}
+function requireModulePkg(id, opts = {}) {
+  return requireModule(join(id, "package.json"), opts);
+}
+function resolveModule(id, opts = {}) {
+  return normalize(_require.resolve(id, {
+    paths: [].concat(
+      global.__DTWO_PREPATHS__,
+      opts.paths || [],
+      process.cwd(),
+      global.__DTWO_PATHS__
+    ).filter(Boolean)
+  }));
+}
+function tryResolveModule(path, opts = {}) {
+  try {
+    return resolveModule(path, opts);
+  } catch (error) {
+    if (error?.code !== "MODULE_NOT_FOUND") {
+      throw error;
+    }
+  }
+  return null;
+}
+function requireModule(id, opts = {}) {
+  const resolvedPath = resolveModule(id, opts);
+  if (opts.clearCache && !isNodeModules(id)) {
+    clearRequireCache(resolvedPath);
+  }
+  const requiredModule = _require(resolvedPath);
+  return requiredModule;
+}
+function importModule(id, opts = {}) {
+  const resolvedPath = resolveModule(id, opts);
+  if (opts.interopDefault !== false) {
+    return import(pathToFileURL(resolvedPath).href).then(interopDefault);
+  }
+  return import(pathToFileURL(resolvedPath).href);
+}
+function tryImportModule(id, opts = {}) {
+  try {
+    return importModule(id, opts).catch(() => void 0);
+  } catch {
+  }
+}
+function tryRequireModule(id, opts = {}) {
+  try {
+    return requireModule(id, opts);
+  } catch (e) {
+  }
+}
+
+function isIgnored(pathname) {
+  const dtwo = tryUseDtwo();
+  if (!dtwo) {
+    return false;
+  }
+  if (!dtwo._ignore) {
+    dtwo._ignore = ignore(dtwo.options.ignoreOptions);
+    dtwo._ignore.add(dtwo.options.ignore);
+    const dtwoignoreFile = join(dtwo.options.rootDir, ".dtwoignore");
+    if (existsSync(dtwoignoreFile)) {
+      dtwo._ignore.add(readFileSync(dtwoignoreFile, "utf-8"));
+    }
+  }
+  const relativePath = relative(dtwo.options.rootDir, pathname);
+  if (relativePath.startsWith("..")) {
+    return false;
+  }
+  return !!(relativePath && dtwo._ignore.ignores(relativePath));
+}
+
+async function resolvePath(path, opts = {}) {
+  const _path = path;
+  path = normalize(path);
+  if (isAbsolute(path) && existsSync(path) && !await isDirectory(path)) {
+    return path;
+  }
+  const dtwo = tryUseDtwo();
+  const cwd = opts.cwd || (dtwo ? dtwo.options.rootDir : process.cwd());
+  const extensions = opts.extensions || (dtwo ? dtwo.options.extensions : [".ts", ".mjs", ".cjs", ".json"]);
+  const modulesDir = dtwo ? dtwo.options.modulesDir : [];
+  path = resolveAlias(path);
+  if (!isAbsolute(path)) {
+    path = resolve(cwd, path);
+  }
+  let _isDir = false;
+  if (existsSync(path)) {
+    _isDir = await isDirectory(path);
+    if (!_isDir) {
+      return path;
+    }
+  }
+  for (const ext of extensions) {
+    const pathWithExt = path + ext;
+    if (existsSync(pathWithExt)) {
+      return pathWithExt;
+    }
+    const pathWithIndex = join(path, "index" + ext);
+    if (_isDir && existsSync(pathWithIndex)) {
+      return pathWithIndex;
+    }
+  }
+  const resolveModulePath = tryResolveModule(_path, { paths: [cwd, ...modulesDir] });
+  if (resolveModulePath) {
+    return resolveModulePath;
+  }
+  return path;
+}
+async function findPath(paths, opts, pathType = "file") {
+  if (!Array.isArray(paths)) {
+    paths = [paths];
+  }
+  for (const path of paths) {
+    const rPath = await resolvePath(path, opts);
+    if (await existsSensitive(rPath)) {
+      const _isDir = await isDirectory(rPath);
+      if (!pathType || pathType === "file" && !_isDir || pathType === "dir" && _isDir) {
+        return rPath;
+      }
+    }
+  }
+  return null;
+}
+function resolveAlias(path, alias) {
+  if (!alias) {
+    alias = tryUseDtwo()?.options.alias || {};
+  }
+  return resolveAlias$1(path, alias);
+}
+function createResolver(base) {
+  if (!base) {
+    throw new Error("`base` argument is missing for createResolver(base)!");
+  }
+  base = base.toString();
+  if (base.startsWith("file://")) {
+    base = dirname(fileURLToPath(base));
+  }
+  return {
+    resolve: (...path) => resolve(base, ...path),
+    resolvePath: (path, opts) => resolvePath(path, { cwd: base, ...opts })
+  };
+}
+async function existsSensitive(path) {
+  if (!existsSync(path)) {
+    return false;
+  }
+  const dirFiles = await promises.readdir(dirname(path));
+  return dirFiles.includes(basename(path));
+}
+async function isDirectory(path) {
+  return (await promises.lstat(path)).isDirectory();
+}
+async function resolveFiles(path, pattern, opts = {}) {
+  const files = await globby(pattern, { cwd: path, followSymbolicLinks: opts.followSymbolicLinks ?? true });
+  return files.map((p) => resolve(path, p)).filter((p) => !isIgnored(p)).sort();
+}
+
+async function installModule(moduleToInstall, _inlineOptions, _dtwo) {
+  const dtwo = useDtwo();
+  const { dtwoModule, inlineOptions } = await normalizeModule(moduleToInstall, _inlineOptions);
+  await dtwoModule(inlineOptions, dtwo);
+  if (typeof moduleToInstall === "string") {
+    dtwo.options.build.transpile.push(moduleToInstall);
+  }
+  dtwo.options._installedModules = dtwo.options._installedModules || [];
+  dtwo.options._installedModules.push({
+    meta: await dtwoModule.getMeta?.(),
+    entryPath: typeof moduleToInstall === "string" ? resolveAlias(moduleToInstall) : void 0
+  });
+}
+async function normalizeModule(dtwoModule, inlineOptions) {
+  const dtwo = useDtwo();
+  if (typeof dtwoModule === "string") {
+    const _src = resolveModule(resolveAlias(dtwoModule), { paths: dtwo.options.modulesDir });
+    const isESM = _src.endsWith(".mjs");
+    try {
+      dtwoModule = isESM ? await importModule(_src) : requireModule(_src);
+    } catch (error) {
+      console.error(`Error while requiring module \`${dtwoModule}\`: ${error}`);
+      throw error;
+    }
+  }
+  if (typeof dtwoModule !== "function") {
+    throw new TypeError("Dtwo module should be a function: " + dtwoModule);
+  }
+  return { dtwoModule, inlineOptions };
+}
+
+async function loadDtwoConfig(opts) {
+  globalThis.defineDtwoConfig = (c) => c;
+  const result = await loadConfig({
+    name: "dtwo",
+    configFile: "dtwo.config",
+    rcFile: ".dtworc",
+    extend: { extendKey: ["theme", "extends"] },
+    dotenv: true,
+    globalRc: true,
+    ...opts
+  });
+  delete globalThis.defineDtwoConfig;
+  const { configFile, layers = [], cwd } = result;
+  const dtwoConfig = result.config;
+  dtwoConfig.rootDir = dtwoConfig.rootDir || cwd;
+  dtwoConfig._dtwoConfigFile = configFile;
+  dtwoConfig._dtwoConfigFiles = [configFile];
+  for (const layer of layers) {
+    layer.config = layer.config || {};
+    layer.config.rootDir = layer.config.rootDir ?? layer.cwd;
+    layer.config.srcDir = resolve(layer.config.rootDir, layer.config.srcDir);
+  }
+  const _layers = layers.filter((layer) => layer.configFile && !layer.configFile.endsWith(".dtworc"));
+  dtwoConfig._layers = _layers;
+  if (!_layers.length) {
+    _layers.push({
+      cwd,
+      config: {
+        rootDir: cwd,
+        srcDir: cwd
+      }
+    });
+  }
+  return await applyDefaults(DtwoConfigSchema, dtwoConfig);
+}
+
+async function loadDtwo(opts) {
+  opts.cwd = opts.cwd || opts.rootDir;
+  opts.overrides = opts.overrides || opts.config || {};
+  const resolveOpts = { paths: opts.cwd };
+  opts.overrides.dev = !!opts.dev;
+  const nearestDtwoPkg = await Promise.all(["dtwo3", "dtwo", "dtwo-edge"].map((pkg2) => resolvePackageJSON(pkg2, { url: opts.cwd }).catch(() => null))).then((r) => r.filter(Boolean).sort((a, b) => b.length - a.length)[0]);
+  if (!nearestDtwoPkg) {
+    throw new Error(`Cannot find any dtwo version from ${opts.cwd}`);
+  }
+  const pkg = await readPackageJSON(nearestDtwoPkg);
+  const majorVersion = parseInt((pkg.version || "").split(".")[0]);
+  if (majorVersion === 3) {
+    const { loadDtwo: loadDtwo3 } = await importModule(pkg._name || pkg.name, resolveOpts);
+    const dtwo2 = await loadDtwo3(opts);
+    return dtwo2;
+  }
+  const { loadDtwo: loadDtwo2 } = await tryImportModule("dtwo-edge", resolveOpts) || await importModule("dtwo", resolveOpts);
+  const dtwo = await loadDtwo2({
+    rootDir: opts.cwd,
+    for: opts.dev ? "dev" : "build",
+    configOverrides: opts.overrides,
+    ready: opts.ready,
+    envConfig: opts.dotenv
+  });
+  return dtwo;
+}
+async function buildDtwo(dtwo) {
+  const resolveOpts = { paths: dtwo.options.rootDir };
+  if (dtwo.options._majorVersion === 3) {
+    const { build: build2 } = await tryImportModule("dtwo3", resolveOpts) || await importModule("dtwo", resolveOpts);
+    return build2(dtwo);
+  }
+  const { build } = await tryImportModule("dtwo-edge", resolveOpts) || await importModule("dtwo", resolveOpts);
+  return build(dtwo);
+}
+
+function addImports(imports) {
+  assertDtwoCompatibility({ bridge: true });
+  useDtwo().hook("imports:extend", (_imports) => {
+    _imports.push(...Array.isArray(imports) ? imports : [imports]);
+  });
+}
+function addImportsDir(dirs) {
+  assertDtwoCompatibility({ bridge: true });
+  useDtwo().hook("imports:dirs", (_dirs) => {
+    for (const dir of Array.isArray(dirs) ? dirs : [dirs]) {
+      _dirs.push(dir);
+    }
+  });
+}
+function addImportsSources(presets) {
+  assertDtwoCompatibility({ bridge: true });
+  useDtwo().hook("imports:sources", (_presets) => {
+    for (const preset of Array.isArray(presets) ? presets : [presets]) {
+      _presets.push(preset);
+    }
+  });
+}
+
+function extendWebpackConfig(fn, options = {}) {
+  const dtwo = useDtwo();
+  if (options.dev === false && dtwo.options.dev) {
+    return;
+  }
+  if (options.build === false && dtwo.options.build) {
+    return;
+  }
+  dtwo.hook("webpack:config", (configs) => {
+    if (options.server !== false) {
+      const config = configs.find((i) => i.name === "server");
+      if (config) {
+        fn(config);
+      }
+    }
+    if (options.client !== false) {
+      const config = configs.find((i) => i.name === "client");
+      if (config) {
+        fn(config);
+      }
+    }
+  });
+}
+function extendWiteConfig(fn, options = {}) {
+  const dtwo = useDtwo();
+  if (options.dev === false && dtwo.options.dev) {
+    return;
+  }
+  if (options.build === false && dtwo.options.build) {
+    return;
+  }
+  if (options.server !== false && options.client !== false) {
+    return dtwo.hook("wite:extend", ({ config }) => fn(config));
+  }
+  dtwo.hook("wite:extendConfig", (config, { isClient, isServer }) => {
+    if (options.server !== false && isServer) {
+      return fn(config);
+    }
+    if (options.client !== false && isClient) {
+      return fn(config);
+    }
+  });
+}
+function addWebpackPlugin(plugin, options) {
+  extendWebpackConfig((config) => {
+    config.plugins = config.plugins || [];
+    if (Array.isArray(plugin)) {
+      config.plugins.push(...plugin);
+    } else {
+      config.plugins.push(plugin);
+    }
+  }, options);
+}
+function addWitePlugin(plugin, options) {
+  extendWiteConfig((config) => {
+    config.plugins = config.plugins || [];
+    if (Array.isArray(plugin)) {
+      config.plugins.push(...plugin);
+    } else {
+      config.plugins.push(plugin);
+    }
+  }, options);
+}
+
+async function addComponentsDir(dir) {
+  const dtwo = useDtwo();
+  await assertDtwoCompatibility({ dtwo: ">=2.13" }, dtwo);
+  dtwo.options.components = dtwo.options.components || [];
+  dtwo.hook("components:dirs", (dirs) => {
+    dirs.push(dir);
+  });
+}
+async function addComponent(opts) {
+  const dtwo = useDtwo();
+  await assertDtwoCompatibility({ dtwo: ">=2.13" }, dtwo);
+  dtwo.options.components = dtwo.options.components || [];
+  const component = {
+    export: opts.export || "default",
+    chunkName: "components/" + kebabCase(opts.name),
+    global: opts.global ?? false,
+    kebabName: kebabCase(opts.name || ""),
+    pascalName: pascalCase(opts.name || ""),
+    prefetch: false,
+    preload: false,
+    mode: "all",
+    shortPath: opts.filePath,
+    ...opts
+  };
+  dtwo.hook("components:extend", (components) => {
+    const existingComponent = components.find((c) => (c.pascalName === component.pascalName || c.kebabName === component.kebabName) && c.mode === component.mode);
+    if (existingComponent) {
+      const name = existingComponent.pascalName || existingComponent.kebabName;
+      console.warn(`Overriding ${name} component.`);
+      Object.assign(existingComponent, component);
+    } else {
+      components.push(component);
+    }
+  });
+}
+
+function normalizeHandlerMethod(handler) {
+  const [, method = void 0] = handler.handler.match(/\.(get|head|patch|post|put|delete|connect|options|trace)(\.\w+)*$/) || [];
+  return {
+    method,
+    ...handler,
+    handler: normalize(handler.handler)
+  };
+}
+function addServerHandler(handler) {
+  useDtwo().options.serverHandlers.push(normalizeHandlerMethod(handler));
+}
+function addDevServerHandler(handler) {
+  useDtwo().options.devServerHandlers.push(handler);
+}
+function addServerPlugin(plugin) {
+  const dtwo = useDtwo();
+  dtwo.options.hole.plugins = dtwo.options.hole.plugins || [];
+  dtwo.options.hole.plugins.push(normalize(plugin));
+}
+function addPrerenderRoutes(routes) {
+  const dtwo = useDtwo();
+  if (!Array.isArray(routes)) {
+    routes = [routes];
+  }
+  routes = routes.filter(Boolean);
+  if (!routes.length) {
+    return;
+  }
+  dtwo.hook("prerender:routes", (ctx) => {
+    for (const route of routes) {
+      ctx.routes.add(route);
+    }
+  });
+}
+function useHole() {
+  const dtwo = useDtwo();
+  if (!dtwo._hole) {
+    throw new Error("Hole is not initialized yet. You can call `useHole()` only after `ready` hook.");
+  }
+  return dtwo._hole;
+}
+
+function addTemplate(_template) {
+  const dtwo = useDtwo();
+  const template = normalizeTemplate(_template);
+  dtwo.options.build.templates = dtwo.options.build.templates.filter((p) => normalizeTemplate(p).filename !== template.filename);
+  dtwo.options.build.templates.push(template);
+  return template;
+}
+function normalizeTemplate(template) {
+  if (!template) {
+    throw new Error("Invalid template: " + JSON.stringify(template));
+  }
+  if (typeof template === "string") {
+    template = { src: template };
+  } else {
+    template = { ...template };
+  }
+  if (template.src) {
+    if (!existsSync(template.src)) {
+      throw new Error("Template not found: " + template.src);
+    }
+    if (!template.filename) {
+      const srcPath = parse(template.src);
+      template.filename = template.fileName || `${basename(srcPath.dir)}.${srcPath.name}.${hash(template.src)}${srcPath.ext}`;
+    }
+  }
+  if (!template.src && !template.getContents) {
+    throw new Error("Invalid template. Either getContents or src options should be provided: " + JSON.stringify(template));
+  }
+  if (!template.filename) {
+    throw new Error("Invalid template. Either filename should be provided: " + JSON.stringify(template));
+  }
+  if (template.filename.endsWith(".d.ts")) {
+    template.write = true;
+  }
+  if (!template.dst) {
+    const dtwo = useDtwo();
+    template.dst = resolve(dtwo.options.buildDir, template.filename);
+  }
+  return template;
+}
+function updateTemplates(options) {
+  return useDtwo().hooks.callHook("builder:generateApp", options);
+}
+
+function addLayout(template, name) {
+  const dtwo = useDtwo();
+  const { filename, src } = addTemplate(template);
+  const layoutName = kebabCase(name || parse(filename).name).replace(/["']/g, "");
+  if (isDtwo2(dtwo)) {
+    const layout = dtwo.options.layouts[layoutName];
+    if (layout) {
+      return logger.warn(
+        `Not overriding \`${layoutName}\` (provided by \`${layout}\`) with \`${src || filename}\`.`
+      );
+    }
+    dtwo.options.layouts[layoutName] = `./${filename}`;
+    if (name === "error") {
+      this.addErrorLayout(filename);
+    }
+    return;
+  }
+  dtwo.hook("app:templates", (app) => {
+    if (layoutName in app.layouts) {
+      const relativePath = relative(dtwo.options.srcDir, app.layouts[layoutName].file);
+      return logger.warn(
+        `Not overriding \`${layoutName}\` (provided by \`~/${relativePath}\`) with \`${src || filename}\`.`
+      );
+    }
+    app.layouts[layoutName] = {
+      file: join("#build", filename),
+      name: layoutName
+    };
+  });
+}
+
+function extendPages(cb) {
+  const dtwo = useDtwo();
+  if (isDtwo2(dtwo)) {
+    dtwo.hook("build:extendRoutes", cb);
+  } else {
+    dtwo.hook("pages:extend", cb);
+  }
+}
+
+function normalizePlugin(plugin) {
+  if (typeof plugin === "string") {
+    plugin = { src: plugin };
+  } else {
+    plugin = { ...plugin };
+  }
+  if (!plugin.src) {
+    throw new Error("Invalid plugin. src option is required: " + JSON.stringify(plugin));
+  }
+  plugin.src = normalize(resolveAlias(plugin.src));
+  if (plugin.ssr) {
+    plugin.mode = "server";
+  }
+  if (!plugin.mode) {
+    const [, mode = "all"] = plugin.src.match(/\.(server|client)(\.\w+)*$/) || [];
+    plugin.mode = mode;
+  }
+  return plugin;
+}
+function addPlugin(_plugin, opts = {}) {
+  const dtwo = useDtwo();
+  const plugin = normalizePlugin(_plugin);
+  dtwo.options.plugins = dtwo.options.plugins.filter((p) => normalizePlugin(p).src !== plugin.src);
+  dtwo.options.plugins[opts.append ? "push" : "unshift"](plugin);
+  return plugin;
+}
+function addPluginTemplate(plugin, opts = {}) {
+  const normalizedPlugin = typeof plugin === "string" ? { src: plugin } : { ...plugin, src: addTemplate(plugin).dst };
+  return addPlugin(normalizedPlugin, opts);
+}
+
+export { addComponent, addComponentsDir, addDevServerHandler, addImports, addImportsDir, addImportsSources, addLayout, addPlugin, addPluginTemplate, addPrerenderRoutes, addServerHandler, addServerPlugin, addTemplate, addWebpackPlugin, addWitePlugin, assertDtwoCompatibility, buildDtwo, checkDtwoCompatibility, clearRequireCache, compileTemplate, createResolver, defineDtwoModule, dtwoCtx, extendPages, extendWebpackConfig, extendWiteConfig, findPath, getDtwoVersion, getRequireCacheItem, hasDtwoCompatibility, importModule, installModule, isDtwo2, isDtwo3, isIgnored, isNodeModules, loadDtwo, loadDtwoConfig, logger, normalizePlugin, normalizeTemplate, requireModule, requireModulePkg, resolveAlias, resolveFiles, resolveModule, resolvePath, scanRequireTree, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseDtwo, updateTemplates, useDtwo, useHole, useLogger };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@dtwo/kit",
+  "version": "3.0.0-rc.13",
+  "repository": "d2js/framework",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@dtwo/schema": "3.0.0-rc.13",
+    "c12": "^1.0.1",
+    "consola": "^2.15.3",
+    "defu": "^6.1.1",
+    "globby": "^13.1.2",
+    "hash-sum": "^2.0.0",
+    "ignore": "^5.2.0",
+    "jiti": "^1.16.0",
+    "knitwork": "^1.0.0",
+    "lodash.template": "^4.5.0",
+    "mlly": "^1.0.0",
+    "pathe": "^1.0.0",
+    "pkg-types": "^1.0.1",
+    "scule": "^1.0.0",
+    "semver": "^7.3.8",
+    "unctx": "^2.1.0",
+    "unimport": "^1.0.0",
+    "untyped": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/lodash.template": "^4",
+    "@types/semver": "^7",
+    "unbuild": "latest"
+  },
+  "engines": {
+    "node": "^14.16.0 || ^16.10.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+  },
+  "scripts": {}
+}