silgi 0.3.12 → 0.4.0

package/dist/ecosystem/nitro/index.mjs

@@ -1,14 +1,13 @@
+import { execSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { resolve, dirname, join } from 'pathe';
-import { l as loadSilgiConfig, r as relativeWithDot } from '../../shared/silgi.b9yhSIGd.mjs';
-import 'c12';
-import 'untyped';
-import 'std-env';
+import { loadOptions } from 'silgi/core';
+import { relativeWithDot } from 'silgi/kit';
 
 const module = {
   name: "silgi",
   setup: async (nitro) => {
-    const silgiConfig = await loadSilgiConfig({});
+    const silgiConfig = await loadOptions({});
     nitro.options.plugins = nitro.options.plugins || [];
     nitro.options.plugins.push(
       fileURLToPath(new URL("runtime/plugin", import.meta.url))
@@ -20,15 +19,27 @@ const module = {
     const tsconfigDir = dirname(tsConfigPath);
     nitro.options.typescript.strict = true;
     nitro.options.typescript.tsConfig ??= {};
-    nitro.options.typescript.tsConfig.include = nitro.options.typescript.tsConfig.include || [];
-    nitro.options.typescript.tsConfig.include.push(join(relativeWithDot(tsconfigDir, silgiConfig.buildDir), "**/*"));
+    nitro.options.typescript.tsConfig.extends = "./silgi.tsconfig.json";
+    nitro.options.typescript.tsConfig.include ??= [];
+    nitro.options.typescript.tsConfig.exclude ??= [];
+    if (silgiConfig.typescript.internalPaths) {
+      nitro.options.alias ||= {};
+      nitro.options.alias = {
+        ...nitro.options.alias,
+        ...silgiConfig.alias
+        // 'silgi/runtime': fileURLToPath(`${new URL(pkgDir, import.meta.url)}dist/runtime/`),
+      };
+    }
+    nitro.options.typescript.tsConfig.include.push(join(relativeWithDot(tsconfigDir, silgiConfig.build.dir), "**/*"));
     nitro.options.typescript.tsConfig.compilerOptions ??= {};
-    nitro.options.typescript.tsConfig.compilerOptions.strict = true;
-    nitro.options.typescript.tsConfig.compilerOptions.allowImportingTsExtensions = true;
+    nitro.options.typescript.tsConfig.compilerOptions.paths ??= {};
+    nitro.hooks.hook("types:extend", async () => {
+      execSync("pnpm silgi prepare", { stdio: "inherit", cwd: nitro.options.rootDir, env: process.env });
+    });
     if (nitro.options.imports) {
       nitro.options.imports.dirs ??= [];
       nitro.options.imports.dirs.push(
-        join(silgiConfig.silgiDir, "**/*")
+        join(silgiConfig.silgi.serverDir, "**/*")
       );
       nitro.options.imports.presets ??= [];
       nitro.options.imports.presets.push({

package/dist/ecosystem/nuxt/module.mjs

@@ -1,10 +1,8 @@
 import { defineNuxtModule, createResolver, addImportsDir } from '@nuxt/kit';
 import { resolvePath } from 'mlly';
 import { join } from 'pathe';
-import { l as loadSilgiConfig, r as relativeWithDot } from '../../shared/silgi.b9yhSIGd.mjs';
-import 'c12';
-import 'untyped';
-import 'std-env';
+import { loadOptions } from 'silgi/core';
+import { relativeWithDot } from 'silgi/kit';
 
 const module = defineNuxtModule({
   meta: {
@@ -19,12 +17,12 @@ const module = defineNuxtModule({
     const { resolve } = createResolver(import.meta.url);
     const runtimeDir = resolve("./runtime");
     const composablesDir = resolve(join(runtimeDir, "./composables"));
-    const silgi = await loadSilgiConfig({});
+    const silgi = await loadOptions({});
     nuxt.options.build.transpile.push("silgi");
     nuxt.options.nitro.modules ||= [];
     nuxt.options.nitro.modules.push(await resolvePath("silgi/ecosystem/nitro"));
     nuxt.hook("prepare:types", ({ references }) => {
-      references.push({ path: relativeWithDot(nuxt.options.buildDir, join(silgi.buildDir, "silgi.d.ts")) });
+      references.push({ path: relativeWithDot(nuxt.options.buildDir, join(silgi.build.dir, "silgi.d.ts")) });
     });
     addImportsDir(composablesDir);
   }

package/dist/kit/index.d.mts

@@ -0,0 +1,90 @@
+import { Buffer } from 'node:buffer';
+import { GraphQLSchema } from 'graphql';
+import { SilgiCLI, GraphQLJSON, SilgiPreset, SilgiPresetMeta } from 'silgi/types';
+import { w as ModuleOptions, y as ModuleDefinition, F as SilgiModule } from '../shared/silgi.DSHNePNA.mjs';
+import 'defu';
+import '@graphql-tools/utils';
+import 'pkg-types';
+import '@standard-schema/spec';
+import 'consola';
+import 'hookable';
+import 'silgi/presets';
+import 'unimport';
+import 'unstorage';
+import 'c12';
+import 'chokidar';
+import 'compatx';
+import 'unimport/unplugin';
+import 'std-env';
+import '../shared/silgi.40ZJYm8F.mjs';
+import 'ignore';
+
+/**
+ * Resolve a module from a given root path using an algorithm patterned on
+ * the upcoming `import.meta.resolve`. It returns a file URL
+ *
+ * @internal
+ */
+declare function tryResolveModule(id: string, url?: string | string[]): Promise<string | undefined>;
+
+declare function writeFile(file: string, contents: Buffer | string, log?: boolean): Promise<void>;
+declare function isDirectory(path: string): Promise<boolean>;
+
+declare function exportGraphQLInterfaceType(silgi: SilgiCLI, schema: GraphQLSchema): void;
+
+declare function extractGraphQLSchemaToJSON(schema: GraphQLSchema): GraphQLJSON;
+
+/**
+ * Define a Silgi 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 defineSilgiModule<TOptions extends ModuleOptions>(definition: ModuleDefinition<TOptions, Partial<TOptions>, false> | SilgiModule<TOptions, Partial<TOptions>, false>): SilgiModule<TOptions, TOptions, false>;
+declare function defineSilgiModule<TOptions extends ModuleOptions>(): {
+    with: <TOptionsDefaults extends Partial<TOptions>>(definition: ModuleDefinition<TOptions, TOptionsDefaults, true> | SilgiModule<TOptions, TOptionsDefaults, true>) => SilgiModule<TOptions, TOptionsDefaults, true>;
+};
+
+declare function prettyPath(p: string, highlight?: boolean): string;
+declare function resolveSilgiPath(path: string, silgiCLIOptions: SilgiCLI['options'], base?: string): string;
+
+declare function defineSilgiPreset<P extends SilgiPreset, M extends SilgiPresetMeta>(preset: P, meta?: M): P & {
+    _meta: SilgiPresetMeta;
+};
+
+interface ResolvePathOptions {
+    modulesDir?: string[];
+    /** Base for resolving paths from. Default is Nuxt rootDir. */
+    cwd?: string;
+    /** An object of aliases. Default is Nuxt configured aliases. */
+    alias?: Record<string, string>;
+    /** The file extensions to try. Default is Nuxt configured extensions. */
+    extensions?: string[];
+    /**
+     * Whether to fallback to the original path if the resolved path does not exist instead of returning the normalized input path.
+     *
+     * @default false
+     */
+    fallbackToOriginal?: boolean;
+}
+/**
+ * Resolve full path to a file or directory respecting Nuxt 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>;
+/**
+ * Resolve path aliases respecting Nuxt 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 resolveSilgiModule(base: string, paths: string[]): Promise<string[]>;
+
+declare function relativeWithDot(from: string, to: string): string;
+
+export { createResolver, defineSilgiModule, defineSilgiPreset, exportGraphQLInterfaceType, extractGraphQLSchemaToJSON, isDirectory, prettyPath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, tryResolveModule, writeFile };

package/dist/kit/index.d.ts

@@ -0,0 +1,90 @@
+import { Buffer } from 'node:buffer';
+import { GraphQLSchema } from 'graphql';
+import { SilgiCLI, GraphQLJSON, SilgiPreset, SilgiPresetMeta } from 'silgi/types';
+import { w as ModuleOptions, y as ModuleDefinition, F as SilgiModule } from '../shared/silgi.D8h2AAVk.js';
+import 'defu';
+import '@graphql-tools/utils';
+import 'pkg-types';
+import '@standard-schema/spec';
+import 'consola';
+import 'hookable';
+import 'silgi/presets';
+import 'unimport';
+import 'unstorage';
+import 'c12';
+import 'chokidar';
+import 'compatx';
+import 'unimport/unplugin';
+import 'std-env';
+import '../shared/silgi.40ZJYm8F.js';
+import 'ignore';
+
+/**
+ * Resolve a module from a given root path using an algorithm patterned on
+ * the upcoming `import.meta.resolve`. It returns a file URL
+ *
+ * @internal
+ */
+declare function tryResolveModule(id: string, url?: string | string[]): Promise<string | undefined>;
+
+declare function writeFile(file: string, contents: Buffer | string, log?: boolean): Promise<void>;
+declare function isDirectory(path: string): Promise<boolean>;
+
+declare function exportGraphQLInterfaceType(silgi: SilgiCLI, schema: GraphQLSchema): void;
+
+declare function extractGraphQLSchemaToJSON(schema: GraphQLSchema): GraphQLJSON;
+
+/**
+ * Define a Silgi 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 defineSilgiModule<TOptions extends ModuleOptions>(definition: ModuleDefinition<TOptions, Partial<TOptions>, false> | SilgiModule<TOptions, Partial<TOptions>, false>): SilgiModule<TOptions, TOptions, false>;
+declare function defineSilgiModule<TOptions extends ModuleOptions>(): {
+    with: <TOptionsDefaults extends Partial<TOptions>>(definition: ModuleDefinition<TOptions, TOptionsDefaults, true> | SilgiModule<TOptions, TOptionsDefaults, true>) => SilgiModule<TOptions, TOptionsDefaults, true>;
+};
+
+declare function prettyPath(p: string, highlight?: boolean): string;
+declare function resolveSilgiPath(path: string, silgiCLIOptions: SilgiCLI['options'], base?: string): string;
+
+declare function defineSilgiPreset<P extends SilgiPreset, M extends SilgiPresetMeta>(preset: P, meta?: M): P & {
+    _meta: SilgiPresetMeta;
+};
+
+interface ResolvePathOptions {
+    modulesDir?: string[];
+    /** Base for resolving paths from. Default is Nuxt rootDir. */
+    cwd?: string;
+    /** An object of aliases. Default is Nuxt configured aliases. */
+    alias?: Record<string, string>;
+    /** The file extensions to try. Default is Nuxt configured extensions. */
+    extensions?: string[];
+    /**
+     * Whether to fallback to the original path if the resolved path does not exist instead of returning the normalized input path.
+     *
+     * @default false
+     */
+    fallbackToOriginal?: boolean;
+}
+/**
+ * Resolve full path to a file or directory respecting Nuxt 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>;
+/**
+ * Resolve path aliases respecting Nuxt 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 resolveSilgiModule(base: string, paths: string[]): Promise<string[]>;
+
+declare function relativeWithDot(from: string, to: string): string;
+
+export { createResolver, defineSilgiModule, defineSilgiPreset, exportGraphQLInterfaceType, extractGraphQLSchemaToJSON, isDirectory, prettyPath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, tryResolveModule, writeFile };

package/dist/kit/index.mjs

@@ -0,0 +1,316 @@
+import { resolvePath as resolvePath$1 } from 'mlly';
+import fsp from 'node:fs/promises';
+import consola, { consola as consola$1 } from 'consola';
+import { relative, resolve, dirname, normalize, isAbsolute, join } from 'pathe';
+import { colors } from 'consola/utils';
+import { getProperty } from 'dot-prop';
+import { extractGraphQLSchemaToJSON as extractGraphQLSchemaToJSON$1 } from 'silgi/kit';
+import { defu } from 'defu';
+import { u as useSilgiCLI, c as checkSilgiCompatibility, t as tryUseSilgiCLI } from '../cli/compatibility.mjs';
+import { existsSync, promises } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { resolveAlias as resolveAlias$1 } from 'pathe/utils';
+import 'semver/functions/satisfies.js';
+import 'silgi/meta';
+import 'unctx';
+
+async function tryResolveModule(id, url = import.meta.url) {
+  try {
+    return await resolvePath$1(id, { url });
+  } catch {
+  }
+}
+
+function prettyPath(p, highlight = true) {
+  p = relative(process.cwd(), p);
+  return highlight ? colors.cyan(p) : p;
+}
+function resolveSilgiPath(path, silgiCLIOptions, base) {
+  if (typeof path !== "string") {
+    throw new TypeError(`Invalid path: ${path}`);
+  }
+  path = _compilePathTemplate(path)(silgiCLIOptions);
+  for (const base2 in silgiCLIOptions.alias) {
+    if (path.startsWith(base2)) {
+      path = silgiCLIOptions.alias[base2] + path.slice(base2.length);
+    }
+  }
+  return resolve(base || silgiCLIOptions.srcDir, path);
+}
+function _compilePathTemplate(contents) {
+  return (params) => contents.replace(/\{\{ ?([\w.]+) ?\}\}/g, (_, match) => {
+    const val = getProperty(params, match);
+    if (!val) {
+      consola.warn(
+        `cannot resolve template param '${match}' in ${contents.slice(0, 20)}`
+      );
+    }
+    return val || `${match}`;
+  });
+}
+
+async function writeFile(file, contents, log = false) {
+  await fsp.mkdir(dirname(file), { recursive: true });
+  await fsp.writeFile(
+    file,
+    contents,
+    typeof contents === "string" ? "utf8" : undefined
+  );
+  if (log) {
+    consola$1.info("Generated", prettyPath(file));
+  }
+}
+async function isDirectory$1(path) {
+  try {
+    return (await fsp.stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function exportGraphQLInterfaceType(silgi, schema) {
+  const schemasJSON = extractGraphQLSchemaToJSON$1(schema);
+  for (const [key, schemaValue] of Object.entries(schemasJSON)) {
+    if (key === "queries") {
+      for (const [queryKey, _queryValue] of Object.entries(schemaValue)) {
+      }
+    }
+    if (key === "mutations") {
+      for (const [mutationKey, _mutationValue] of Object.entries(schemaValue)) {
+      }
+    }
+    if (key === "types") {
+      for (const [typeName, typeValue] of Object.entries(schemaValue)) {
+        if (typeof typeValue === "string" && typeValue.startsWith("$ref:")) {
+          const refName = typeValue.replace("$ref:", "");
+          const refFields = schemasJSON.references?.[refName];
+          if (refFields) {
+            for (const fieldName of Object.keys(refFields)) {
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+function extractGraphQLSchemaToJSON(schema) {
+  const result = {
+    queries: {},
+    mutations: {},
+    types: {},
+    inputs: {},
+    references: {}
+    // Schema içindeki tüm referansları tutacak
+  };
+  function getTypeReference(type) {
+    if (["GraphQLScalarType", "GraphQLEnumType"].includes(type.constructor.name)) {
+      return type.name;
+    }
+    const typeName = type.name.toLowerCase();
+    if (!result.references[typeName]) {
+      const fields = {};
+      const typeFields = type.constructor.name === "GraphQLInputObjectType" ? type.getFields() : type._fields;
+      Object.entries(typeFields || {}).forEach(([fieldName, field]) => {
+        if (field?.type) {
+          if (["GraphQLObjectType", "GraphQLInputObjectType"].includes(field.type.constructor.name)) {
+            fields[fieldName] = `$ref:${field.type.name.toLowerCase()}`;
+          } else {
+            fields[fieldName] = field.type.name;
+          }
+        }
+      });
+      result.references[typeName] = fields;
+    }
+    return `$ref:${typeName}`;
+  }
+  Object.entries(schema.getQueryType()?.getFields() || {}).forEach(([name, field]) => {
+    result.queries[name] = {
+      input: {},
+      output: field.type.name === "String" ? "String" : `$ref:${field.type.name.toLowerCase()}`
+    };
+    if (field.args?.length) {
+      field.args.forEach((arg) => {
+        result.queries[name].input[arg.name] = getTypeReference(arg.type);
+      });
+    }
+  });
+  Object.entries(schema.getMutationType()?.getFields() || {}).forEach(([name, field]) => {
+    result.mutations[name] = {
+      input: {},
+      output: field.type.name === "String" ? "String" : `$ref:${field.type.name.toLowerCase()}`
+    };
+    if (field.args?.length) {
+      field.args.forEach((arg) => {
+        result.mutations[name].input[arg.name] = getTypeReference(arg.type);
+      });
+    }
+  });
+  Object.entries(schema.getTypeMap()).forEach(([typeName, type]) => {
+    if (typeName.startsWith("__") || ["Query", "Mutation"].includes(typeName)) {
+      return;
+    }
+    if (["GraphQLScalarType", "GraphQLEnumType"].includes(type.constructor.name)) {
+      return;
+    }
+    const typeKey = typeName.toLowerCase();
+    if (type.constructor.name === "GraphQLInputObjectType") {
+      result.inputs[typeKey] = `$ref:${typeKey}`;
+    } else {
+      result.types[typeKey] = `$ref:${typeKey}`;
+    }
+    getTypeReference(type);
+  });
+  return result;
+}
+
+function defineSilgiModule(definition) {
+  if (definition) {
+    return _defineSilgiModule(definition);
+  }
+  return {
+    with: (definition2) => _defineSilgiModule(definition2)
+  };
+}
+function _defineSilgiModule(definition) {
+  if (typeof definition === "function") {
+    return _defineSilgiModule({ setup: definition });
+  }
+  const module = defu(definition, { meta: {} });
+  module.meta.configKey ||= module.meta.name;
+  async function getOptions(inlineOptions, silgi = useSilgiCLI()) {
+    const nuxtConfigOptionsKey = module.meta.configKey || module.meta.name;
+    const nuxtConfigOptions = nuxtConfigOptionsKey && nuxtConfigOptionsKey in silgi.options ? silgi.options[nuxtConfigOptionsKey] : {};
+    const optionsDefaults = module.defaults instanceof Function ? await module.defaults(silgi) : module.defaults ?? {};
+    const options = defu(inlineOptions, nuxtConfigOptions, optionsDefaults);
+    return Promise.resolve(options);
+  }
+  async function normalizedModule(inlineOptions, silgi = tryUseSilgiCLI()) {
+    if (!silgi) {
+      throw new TypeError("Cannot use module outside of Silgi context");
+    }
+    const uniqueKey = module.meta.configKey || module.meta.name;
+    if (uniqueKey) {
+      silgi._requiredModules ||= {};
+      if (silgi._requiredModules[uniqueKey]) {
+        return false;
+      }
+      silgi._requiredModules[uniqueKey] = true;
+    }
+    if (module.meta.compatibility) {
+      const issues = await checkSilgiCompatibility(module.meta.compatibility, silgi);
+      if (issues.length) {
+        silgi.logger.warn(`Module \`${module.meta.name}\` is disabled due to incompatibility issues:
+${issues.toString()}`);
+        return;
+      }
+    }
+    const _options = await getOptions(inlineOptions, silgi);
+    if (module.hooks) {
+      silgi.hooks.addHooks(module.hooks);
+    }
+    const start = performance.now();
+    const res = await module.setup?.call(null, _options, silgi) ?? {};
+    const perf = performance.now() - start;
+    const setupTime = Math.round(perf * 100) / 100;
+    if (setupTime > 5e3 && uniqueKey !== "@silgi/telemetry") {
+      silgi.logger.warn(`Slow module \`${uniqueKey || "<no name>"}\` took \`${setupTime}ms\` to setup.`);
+    } else if (silgi.options.debug) {
+      silgi.logger.info(`Module \`${uniqueKey || "<no name>"}\` took \`${setupTime}ms\` to setup.`);
+    }
+    if (res === false) {
+      return false;
+    }
+    return defu(res, {
+      timings: {
+        setup: setupTime
+      }
+    });
+  }
+  normalizedModule.getMeta = () => Promise.resolve(module.meta);
+  normalizedModule.getOptions = getOptions;
+  return normalizedModule;
+}
+
+function defineSilgiPreset(preset, meta) {
+  if (meta?.url && typeof preset !== "function") ;
+  return { ...preset, _meta: meta };
+}
+
+async function resolvePath(path, opts = {}) {
+  const _path = path;
+  path = normalize(path);
+  if (isAbsolute(path)) {
+    if (existsSync(path) && !await isDirectory(path)) {
+      return path;
+    }
+  }
+  const cwd = opts.cwd || process.cwd();
+  const extensions = opts.extensions || [".ts", ".mjs", ".cjs", ".json"];
+  const modulesDir = opts.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 = await resolvePath$1(_path, { url: [cwd, ...modulesDir] }).catch(() => null);
+  if (resolveModulePath) {
+    return resolveModulePath;
+  }
+  return opts.fallbackToOriginal ? _path : path;
+}
+async function isDirectory(path) {
+  return (await promises.lstat(path)).isDirectory();
+}
+function resolveAlias(path, 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 resolveSilgiModule(base, paths) {
+  const resolved = [];
+  const resolver = createResolver(base);
+  for (const path of paths) {
+    if (path.startsWith(base)) {
+      resolved.push(path.split("/index.ts")[0]);
+    } else {
+      const resolvedPath = await resolver.resolvePath(path);
+      resolved.push(resolvedPath.slice(0, resolvedPath.lastIndexOf(path) + path.length));
+    }
+  }
+  return resolved;
+}
+
+const RELATIVE_RE = /^([^.])/;
+function relativeWithDot(from, to) {
+  return relative(from, to).replace(RELATIVE_RE, "./$1") || ".";
+}
+
+export { createResolver, defineSilgiModule, defineSilgiPreset, exportGraphQLInterfaceType, extractGraphQLSchemaToJSON, isDirectory$1 as isDirectory, prettyPath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, tryResolveModule, writeFile };

package/dist/meta/index.d.mts

@@ -0,0 +1,3 @@
+const version = "0.4.0";
+
+export { version };

package/dist/meta/index.d.ts

@@ -0,0 +1,3 @@
+const version = "0.4.0";
+
+export { version };

package/dist/meta/index.mjs

@@ -0,0 +1 @@
+export { v as version } from '../_chunks/index.mjs';

package/dist/presets/_all.gen.d.ts

@@ -0,0 +1,2 @@
+declare const _default: readonly [any, any, any];
+export default _default;

package/dist/presets/_all.gen.mjs

@@ -0,0 +1,8 @@
+import _h3 from "./h3/preset.mjs";
+import _nitro from "./nitro/preset.mjs";
+import _npmpackage from "./npmpackage/preset.mjs";
+export default [
+  ..._h3,
+  ..._nitro,
+  ..._npmpackage
+];

package/dist/presets/_resolve.d.ts

@@ -0,0 +1,8 @@
+import type { SilgiPreset, SilgiPresetMeta } from 'silgi/types';
+import { type CompatibilityDateSpec } from 'compatx';
+export declare function resolvePreset(name: string, opts: {
+    static?: boolean;
+    compatibilityDate?: false | CompatibilityDateSpec;
+}): Promise<(SilgiPreset & {
+    _meta?: SilgiPresetMeta;
+}) | undefined>;

package/dist/presets/_resolve.mjs

@@ -0,0 +1,58 @@
+import {
+  formatCompatibilityDate,
+  resolveCompatibilityDatesFromEnv
+} from "compatx";
+import { kebabCase } from "scule";
+import { provider } from "std-env";
+import allPresets from "./_all.gen.mjs";
+const _stdProviderMap = {
+  aws_amplify: "aws",
+  azure_static: "azure",
+  cloudflare_pages: "cloudflare"
+};
+export async function resolvePreset(name, opts) {
+  const _name = kebabCase(name) || provider;
+  const _compatDates = opts.compatibilityDate ? resolveCompatibilityDatesFromEnv(opts.compatibilityDate) : false;
+  const matches = allPresets.filter((preset2) => {
+    const names = [preset2._meta.name, preset2._meta.stdName, ...preset2._meta.aliases || []].filter(Boolean);
+    if (!names.includes(_name)) {
+      return false;
+    }
+    if (_compatDates) {
+      const _date = _compatDates[_stdProviderMap[preset2._meta.stdName]] || _compatDates[preset2._meta.stdName] || _compatDates[preset2._meta.name] || _compatDates.default;
+      if (_date && preset2._meta.compatibilityDate && new Date(preset2._meta.compatibilityDate) > new Date(_date)) {
+        return false;
+      }
+    }
+    return true;
+  }).sort((a, b) => {
+    const aDate = new Date(a._meta.compatibilityDate || 0);
+    const bDate = new Date(b._meta.compatibilityDate || 0);
+    return bDate > aDate ? 1 : -1;
+  });
+  const preset = matches.find(
+    (p) => (p._meta.static || false) === (opts?.static || false)
+  ) || matches[0];
+  if (typeof preset === "function") {
+    return preset();
+  }
+  if (!name && !preset) {
+    return opts?.static ? resolvePreset("static", opts) : resolvePreset("node-server", opts);
+  }
+  if (name && !preset) {
+    const options = allPresets.filter((p) => p._meta.name === name || p._meta.stdName === name || p._meta.aliases?.includes(name)).sort((a, b) => (a._meta.compatibilityDate || 0) > (b._meta.compatibilityDate || 0) ? 1 : -1);
+    if (options.length > 0) {
+      let msg = `Preset "${name}" cannot be resolved with current compatibilityDate: ${formatCompatibilityDate(_compatDates || "")}.
+
+`;
+      for (const option of options) {
+        msg += `
+- ${option._meta.name} (requires compatibilityDate >= ${option._meta.compatibilityDate})`;
+      }
+      const err = new Error(msg);
+      Error.captureStackTrace?.(err, resolvePreset);
+      throw err;
+    }
+  }
+  return preset;
+}

package/dist/presets/_types.gen.d.ts

@@ -0,0 +1,5 @@
+export interface PresetOptions {
+}
+export declare const presetsWithConfig: readonly [];
+export type PresetName = "h3" | "nitro" | "npm-package";
+export type PresetNameInput = "h3" | "nitro" | "npm-package" | "npmPackage" | "npm_package" | (string & {});

package/dist/presets/_types.gen.mjs

@@ -0,0 +1 @@
+export const presetsWithConfig = [];