silgi 0.42.4 → 0.43.0

package/dist/kit/resolve.mjs

@@ -0,0 +1,82 @@
+import { dirname, isAbsolute, join, normalize, resolve } from "pathe";
+import { tryUseSilgiCLI } from "silgi";
+import { existsSync, promises } from "node:fs";
+import { resolvePath } from "mlly";
+import { fileURLToPath } from "node:url";
+import { resolveAlias } from "pathe/utils";
+
+//#region src/kit/resolve.ts
+/**
+* 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
+*/
+async function resolvePath$1(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$1(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(_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();
+}
+/**
+* Resolve path aliases respecting Nuxt alias options
+*/
+function resolveAlias$1(path, alias) {
+	alias ||= tryUseSilgiCLI()?.options.alias || {};
+	return resolveAlias(path, alias || {});
+}
+/**
+* Create a relative resolver
+*/
+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$1(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;
+}
+
+//#endregion
+export { createResolver, resolveAlias$1 as resolveAlias, resolvePath$1 as resolvePath, resolveSilgiModule };

package/dist/kit/template.d.mts

@@ -0,0 +1,14 @@
+import { ResolvedSilgiTemplate, SilgiTemplate } from "silgi/types";
+
+//#region src/kit/template.d.ts
+
+/**
+* Renders given template during build into the virtual file system (and optionally to disk in the project `buildDir`)
+*/
+declare function addTemplate<T>(_template: SilgiTemplate<T> | string): ResolvedSilgiTemplate<T>;
+/**
+* Normalize a silgi template object
+*/
+declare function normalizeTemplate<T>(template: SilgiTemplate<T> | string, buildDir?: string): ResolvedSilgiTemplate<T>;
+//#endregion
+export { addTemplate as addTemplate$1, normalizeTemplate as normalizeTemplate$1 };

package/dist/kit/template.mjs

@@ -0,0 +1,59 @@
+import { filterInPlace } from "./utils.mjs";
+import { basename, parse, resolve } from "pathe";
+import { useSilgiCLI } from "silgi";
+import { hash } from "silgi/kit";
+import { existsSync } from "node:fs";
+
+//#region src/kit/template.ts
+/**
+* Renders given template during build into the virtual file system (and optionally to disk in the project `buildDir`)
+*/
+function addTemplate$1(_template) {
+	const silgi = useSilgiCLI();
+	const template = normalizeTemplate$1(_template);
+	filterInPlace(silgi.options.build.templates, (p) => normalizeTemplate$1(p).dst !== template.dst);
+	silgi.options.build.templates.push(template);
+	return template;
+}
+/**
+* Normalize a silgi template object
+*/
+function normalizeTemplate$1(template, buildDir) {
+	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\` should be provided: ${JSON.stringify(template)}`);
+	if (!template.filename) throw new Error(`Invalid template. \`filename\` must be provided: ${JSON.stringify(template)}`);
+	if (template.filename.endsWith(".d.ts")) template.write = true;
+	if (!template.dst) {
+		const silgi = useSilgiCLI();
+		let dir;
+		switch (template.where) {
+			case ".silgi":
+				dir = silgi.options.build.dir;
+				break;
+			case "server":
+				dir = silgi.options.silgi.serverDir;
+				break;
+			case "client":
+				dir = silgi.options.silgi.clientDir;
+				break;
+			case "root":
+				dir = silgi.options.rootDir;
+				break;
+			default: dir = silgi.options.silgi.serverDir;
+		}
+		template.dst = resolve(buildDir ?? dir, template.filename);
+	}
+	return template;
+}
+
+//#endregion
+export { addTemplate$1 as addTemplate, normalizeTemplate$1 as normalizeTemplate };

package/dist/kit/useRequest.d.mts

@@ -0,0 +1,19 @@
+import { SilgiEvent } from "silgi/types";
+import { IncomingMessage } from "node:http";
+
+//#region src/kit/useRequest.d.ts
+
+/**
+* @deprecated
+*/
+declare function useRequest<T extends IncomingMessage>(event: SilgiEvent): T | (IncomingMessage & {
+  originalUrl?: string;
+});
+/**
+* Extract the client's IP address from request headers with high accuracy
+* @param req - The incoming HTTP request (Fetch API Request)
+* @returns The client's IP address or empty string if not found
+*/
+declare function getIpAddress(req: Request): string;
+//#endregion
+export { getIpAddress as getIpAddress$1, useRequest as useRequest$1 };

package/dist/kit/useRequest.mjs

@@ -0,0 +1,63 @@
+import { useSilgi } from "silgi";
+
+//#region src/kit/useRequest.ts
+/**
+* @deprecated
+*/
+function useRequest(event) {
+	const silgi = useSilgi();
+	if (silgi.options.present === "nuxt" || silgi.options.present === "nitro" || silgi.options.present === "h3") return event.node.req;
+	return event;
+}
+/**
+* Extract the client's IP address from request headers with high accuracy
+* @param req - The incoming HTTP request (Fetch API Request)
+* @returns The client's IP address or empty string if not found
+*/
+function getIpAddress(req) {
+	const headers = [
+		"cf-connecting-ip",
+		"true-client-ip",
+		"x-real-ip",
+		"x-forwarded-for",
+		"x-client-ip",
+		"x-forwarded",
+		"forwarded",
+		"forwarded-for",
+		"x-appengine-user-ip",
+		"x-cluster-client-ip",
+		"fastly-client-ip",
+		"x-azure-clientip",
+		"x-original-forwarded-for",
+		"x-lb-forwarded-for",
+		"cdn-loop"
+	];
+	for (const header of headers) {
+		const value = req.headers.get(header);
+		if (!value) continue;
+		let ip;
+		if (header === "x-forwarded-for" || header === "forwarded-for" || header === "x-original-forwarded-for") ip = value.split(",")[0];
+		else if (header === "forwarded") {
+			const match = value.match(/for=([^;]+)/);
+			ip = match?.[1]?.trim().replace(/^\[|\]$/g, "") ?? "";
+		} else ip = value;
+		const cleanIp = ip.trim();
+		if (cleanIp && isValidIp(cleanIp)) return cleanIp;
+	}
+	return "";
+}
+/**
+* Validates if a string is a valid IPv4 or IPv6 address
+* Optimized for performance in high-traffic applications
+* @param ip - The IP address to validate
+* @returns true if the IP is valid
+*/
+function isValidIp(ip) {
+	if (ip === "::1" || ip === "localhost" || ip === "127.0.0.1") return true;
+	if (/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(ip)) return true;
+	if (/^[0-9a-f:]+$/i.test(ip)) return true;
+	return false;
+}
+
+//#endregion
+export { getIpAddress, useRequest };

package/dist/kit/utils.d.mts

@@ -0,0 +1,34 @@
+import { PresetName } from "silgi/presets";
+import { SilgiCLI } from "silgi/types";
+
+//#region src/kit/utils.d.ts
+declare function relativeWithDot(from: string, to: string): string;
+declare function toArray<T>(value: T | T[]): T[];
+/**
+* Filter out items from an array in place. This function mutates the array.
+* `predicate` get through the array from the end to the start for performance.
+*
+* This function should be faster than `Array.prototype.filter` on large arrays.
+*/
+declare function filterInPlace<T>(array: T[], predicate: (item: T, index: number, arr: T[]) => unknown): T[];
+declare const MODE_RE: RegExp;
+/**
+* Check if a Silgi module is installed by name.
+*
+* This will check both the installed modules and the modules to be installed. Note
+* that it cannot detect if a module is _going to be_ installed programmatically by another module.
+*/
+declare function hasSilgiModule(moduleKey: string, silgi?: SilgiCLI): boolean;
+declare function hasInstalledModule(moduleKey: string, silgi?: SilgiCLI): boolean;
+declare const baseHeaderBannerComment: string[];
+declare function processFilePath(src: string): string;
+declare function isPresents(names: PresetName[]): boolean;
+declare function isRuntimePresents(names: PresetName[]): boolean;
+declare function removeExtension(filePath: string, force?: boolean): string;
+declare function getServicePath(_route: string): {
+  method: string;
+  type: string;
+  route: string;
+};
+//#endregion
+export { MODE_RE as MODE_RE$1, baseHeaderBannerComment as baseHeaderBannerComment$1, filterInPlace as filterInPlace$1, getServicePath as getServicePath$1, hasInstalledModule as hasInstalledModule$2, hasSilgiModule as hasSilgiModule$1, isPresents as isPresents$1, isRuntimePresents as isRuntimePresents$1, processFilePath as processFilePath$1, relativeWithDot as relativeWithDot$1, removeExtension as removeExtension$1, toArray as toArray$1 };

package/dist/kit/utils.mjs

@@ -0,0 +1,90 @@
+import { extname, relative } from "pathe";
+import { useSilgi, useSilgiCLI } from "silgi";
+
+//#region src/kit/utils.ts
+const RELATIVE_RE = /^([^.])/;
+function relativeWithDot(from, to) {
+	return relative(from, to).replace(RELATIVE_RE, "./$1") || ".";
+}
+function toArray(value) {
+	return Array.isArray(value) ? value : [value];
+}
+/**
+* Filter out items from an array in place. This function mutates the array.
+* `predicate` get through the array from the end to the start for performance.
+*
+* This function should be faster than `Array.prototype.filter` on large arrays.
+*/
+function filterInPlace(array, predicate) {
+	for (let i = array.length; i--;) if (!predicate(array[i], i, array)) array.splice(i, 1);
+	return array;
+}
+const MODE_RE = /\.(server|client)(\.\w+)*$/;
+/**
+* Check if a Silgi module is installed by name.
+*
+* This will check both the installed modules and the modules to be installed. Note
+* that it cannot detect if a module is _going to be_ installed programmatically by another module.
+*/
+function hasSilgiModule(moduleKey, silgi = useSilgiCLI()) {
+	return silgi.scanModules.some(({ meta }) => meta.configKey === moduleKey) || Object.keys(silgi.scanModules).includes(moduleKey);
+}
+function hasInstalledModule(moduleKey, silgi = useSilgiCLI()) {
+	const find = silgi.scanModules.find(({ meta }) => meta.configKey === moduleKey);
+	return find?.installed ?? false;
+}
+const baseHeaderBannerComment = [
+	"// DO NOT EDIT THIS FILE",
+	"// This file is generated by Silgi",
+	"/* eslint-disable */",
+	"/* prettier-ignore */",
+	"/* tslint:disable */"
+];
+function processFilePath(src) {
+	const silgi = useSilgiCLI();
+	if (silgi.options.typescript.removeFileExtension) {
+		src = src.replace(/\.ts$/, "");
+		return src;
+	}
+	return src;
+}
+function isPresents(names) {
+	const silgi = useSilgiCLI();
+	return names.filter((name) => silgi.options.preset.includes(name)).length > 0;
+}
+function isRuntimePresents(names) {
+	const silgi = useSilgi();
+	return names.includes(silgi.options.present);
+}
+function removeExtension(filePath, force = false) {
+	const silgi = useSilgiCLI();
+	if (silgi.options.typescript.removeFileExtension || force) {
+		const ext = extname(filePath);
+		return ext ? filePath.slice(0, -ext.length) : filePath;
+	}
+	return filePath;
+}
+function getServicePath(_route) {
+	let method = "";
+	let type = "";
+	let route = _route;
+	const parts = route.split(":");
+	if (parts.length === 3) {
+		type = parts[0] ? parts[0].toLowerCase() : "";
+		method = parts[1] ? parts[1].toUpperCase() : "";
+		if (method === "GLOBAL" || method === "ALL") method = "";
+		route = parts[2] ?? "";
+	} else if (parts.length === 2) {
+		method = parts[0] ? parts[0].toUpperCase() : "";
+		if (method === "GLOBAL" || method === "ALL") method = "";
+		route = parts[1] ?? "";
+	}
+	return {
+		method,
+		type,
+		route
+	};
+}
+
+//#endregion
+export { MODE_RE, baseHeaderBannerComment, filterInPlace, getServicePath, hasInstalledModule, hasSilgiModule, isPresents, isRuntimePresents, processFilePath, relativeWithDot, removeExtension, toArray };

package/dist/package.mjs

@@ -0,0 +1,176 @@
+//#region package.json
+var name = "silgi";
+var type = "module";
+var version = "0.43.0";
+var private$1 = false;
+var packageManager = "pnpm@10.11.0";
+var sideEffects = false;
+var exports = {
+	"./package.json": "./package.json",
+	".": "./dist/core/index.mjs",
+	"./core": "./dist/core/index.mjs",
+	"./build": "./dist/build.mjs",
+	"./cli": "./dist/cli/index.mjs",
+	"./cli/config": "./dist/cli/config/index.mjs",
+	"./kit": "./dist/kit/index.mjs",
+	"./config": "./lib/config.mjs",
+	"./types": "./dist/types/index.d.mts",
+	"./meta": "./lib/meta.mjs",
+	"./presets": { "import": "./dist/presets/index.mjs" },
+	"./runtime": { "import": "./dist/runtime/index.mjs" },
+	"./runtime/internal/nitro": { "import": "./dist/runtime/internal/nitro.mjs" },
+	"./runtime/internal/debug": { "import": "./dist/runtime/internal/debug.mjs" },
+	"./runtime/internal": { "import": "./dist/runtime/internal/index.mjs" },
+	"./runtime/internal/nuxt": { "import": "./dist/runtime/internal/nuxt.mjs" },
+	"./runtime/meta": "./lib/runtime-meta.mjs"
+};
+var main = "./dist/core/index.mjs";
+var types = "./dist/types/index.d.mts";
+var bin = { "silgi": "./dist/cli/index.mjs" };
+var files = [
+	"bin",
+	"dist",
+	"lib"
+];
+var scripts = {
+	"build:package": "tsdown",
+	"build": "pnpm gen-presets && pnpm build:package",
+	"build:prepare": "pnpm watch",
+	"typecheck": "tsc --noEmit",
+	"watch": "pnpm gen-presets && tsdown --watch",
+	"dev:k6": "k6 run ./__tests__/k6.js",
+	"test": "vitest",
+	"test:coverage": "vitest run --coverage.enabled true",
+	"lint": "eslint .",
+	"lint:fix": "eslint . --fix",
+	"silgi": "tsx cli/index.ts",
+	"release": "pnpm gen-presets && pnpm tsdown && pnpm publish --no-git-checks --access public",
+	"release:beta": "pnpm release --tag beta",
+	"generate": "pnpm --filter './examples/**' silgi:prepare",
+	"gen-presets": "pnpm jiti scripts/gen-presets.ts",
+	"all:delete": "find . -type d \\( -name \"node_modules\" -o -name \"dist\" \\) -prune -exec rm -rf {} +"
+};
+var peerDependencies = {
+	"@fastify/deepmerge": ">=3.0.0",
+	"@nuxt/kit": ">=3.16.1",
+	"@nuxt/schema": ">=3.16.1",
+	"@silgi/ecosystem": ">=0.4.4",
+	"h3": ">=1.15.1",
+	"nitropack": ">=2.11.7",
+	"nuxt": ">=3.16.1",
+	"typescript": ">=5.8.2",
+	"vue": ">=3.5.13",
+	"zod": ">=3.24.2"
+};
+var peerDependenciesMeta = {
+	"@nuxt/kit": { "optional": true },
+	"@nuxt/schema": { "optional": true },
+	"h3": { "optional": true },
+	"nitropack": { "optional": true },
+	"nuxt": { "optional": true },
+	"vue": { "optional": true },
+	"zod": { "optional": true }
+};
+var dependencies = {
+	"@antfu/ni": "^25.0.0",
+	"@clack/prompts": "catalog:",
+	"@fastify/deepmerge": "catalog:",
+	"@graphql-tools/utils": "^10.8.6",
+	"@standard-community/standard-json": "^0.2.0",
+	"apiful": "^3.1.2",
+	"c12": "catalog:",
+	"chokidar": "catalog:",
+	"citty": "catalog:",
+	"compatx": "catalog:",
+	"consola": "catalog:",
+	"crossws": "^0.4.1",
+	"defu": "catalog:",
+	"destr": "catalog:",
+	"dev-jiti": "catalog:",
+	"dot-prop": "catalog:",
+	"dotenv": "catalog:",
+	"escape-string-regexp": "catalog:",
+	"exsolve": "^1.0.5",
+	"graphql": "^16.11.0",
+	"hookable": "catalog:",
+	"ignore": "catalog:",
+	"klona": "catalog:",
+	"knitwork": "catalog:",
+	"magicast": "^0.3.5",
+	"micromatch": "^4.0.8",
+	"mlly": "catalog:",
+	"ofetch": "catalog:",
+	"ohash": "catalog:",
+	"oxc-parser": "^0.72.0",
+	"pathe": "catalog:",
+	"perfect-debounce": "^1.0.0",
+	"picocolors": "catalog:",
+	"pkg-types": "catalog:",
+	"rfc6902": "^5.1.2",
+	"rou3": "^0.6.1",
+	"scule": "catalog:",
+	"semver": "catalog:",
+	"srvx": "^0.7.2",
+	"std-env": "catalog:",
+	"tinyexec": "^1.0.1",
+	"tinyglobby": "^0.2.14",
+	"ufo": "catalog:",
+	"unadapter": "^0.1.2",
+	"unctx": "catalog:",
+	"unimport": "catalog:",
+	"unstorage": "catalog:",
+	"untyped": "catalog:"
+};
+var devDependencies = {
+	"@antfu/eslint-config": "catalog:",
+	"@nuxt/kit": "catalog:",
+	"@nuxt/schema": "catalog:",
+	"@silgi/ecosystem": "catalog:",
+	"@types/micromatch": "^4.0.9",
+	"@types/node": "catalog:",
+	"@types/semver": "catalog:",
+	"@vitest/coverage-v8": "catalog:",
+	"eslint": "catalog:",
+	"h3": "catalog:",
+	"nitropack": "catalog:",
+	"nuxt": "catalog:",
+	"tsdown": "^0.12.4",
+	"typescript": "catalog:",
+	"vitest": "catalog:",
+	"vue": "catalog:",
+	"zod": "catalog:"
+};
+var pnpm = {
+	"onlyBuiltDependencies": [
+		"@parcel/watcher",
+		"esbuild",
+		"vue-demi"
+	],
+	"overrides": { "silgi": "link:." }
+};
+var resolutions = { "silgi": "link:." };
+var publishConfig = { "access": "public" };
+var package_default = {
+	name,
+	type,
+	version,
+	private: private$1,
+	packageManager,
+	sideEffects,
+	exports,
+	main,
+	types,
+	bin,
+	files,
+	scripts,
+	peerDependencies,
+	peerDependenciesMeta,
+	dependencies,
+	devDependencies,
+	pnpm,
+	resolutions,
+	publishConfig
+};
+
+//#endregion
+export { package_default };

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

@@ -1,3 +1,6 @@
-import type { SilgiPreset } from "silgi/types";
+import { SilgiPreset } from "silgi/types";
+
+//#region src/presets/_all.gen.d.ts
 declare const presets: readonly SilgiPreset[];
-export default presets;
+//#endregion
+export { presets as default };

package/dist/presets/_all.gen.mjs

@@ -1,15 +1,18 @@
-import _h3  from "./h3/preset.mjs";
-import _hono  from "./hono/preset.mjs";
-import _next  from "./next/preset.mjs";
-import _nitro  from "./nitro/preset.mjs";
-import _npmpackage  from "./npmpackage/preset.mjs";
-import _nuxt  from "./nuxt/preset.mjs";
+import preset_default from "./h3/preset.mjs";
+import preset_default$1 from "./hono/preset.mjs";
+import preset_default$2 from "./nitro/preset.mjs";
+import preset_default$3 from "./npmpackage/preset.mjs";
+import preset_default$4 from "./nuxt/preset.mjs";
+
+//#region src/presets/_all.gen.ts
 const presets = [
-  ..._h3,
-  ..._hono,
-  ..._next,
-  ..._nitro,
-  ..._npmpackage,
-  ..._nuxt
+	...preset_default,
+	...preset_default$1,
+	...preset_default$2,
+	...preset_default$3,
+	...preset_default$4
 ];
-export default presets;
+var _all_gen_default = presets;
+
+//#endregion
+export { _all_gen_default as default };

package/dist/presets/_resolve.d.mts

@@ -1,8 +1,12 @@
-import type { CompatibilityDateSpec } from 'compatx';
-import type { SilgiPreset, SilgiPresetMeta } from 'silgi/types';
-export declare function resolvePreset(name: string, opts: {
-    static?: boolean;
-    compatibilityDate?: false | CompatibilityDateSpec;
+import { CompatibilityDateSpec } from "compatx";
+import { SilgiPreset, SilgiPresetMeta } from "silgi/types";
+
+//#region src/presets/_resolve.d.ts
+declare function resolvePreset(name: string, opts: {
+  static?: boolean;
+  compatibilityDate?: false | CompatibilityDateSpec;
 }): Promise<(SilgiPreset & {
-    _meta?: SilgiPresetMeta;
+  _meta?: SilgiPresetMeta;
 }) | undefined>;
+//#endregion
+export { resolvePreset };