silgi 0.42.5 → 0.43.0

package/dist/core/utils/storage.mjs

@@ -0,0 +1,54 @@
+import { useSilgi } from "../unctx.mjs";
+import { createError } from "../error.mjs";
+import { replaceRuntimeValues } from "./runtime.mjs";
+import { useRuntimeConfig } from "silgi/runtime";
+import { klona } from "klona";
+import { builtinDrivers, createStorage, prefixStorage } from "unstorage";
+import { Buffer } from "node:buffer";
+
+//#region src/core/utils/storage.ts
+async function createStorage$1(silgi) {
+	const storage = createStorage();
+	const runtime = useRuntimeConfig();
+	const mounts = klona({
+		...silgi.options.storage,
+		...silgi.options.devStorage
+	});
+	for (const [path, opts] of Object.entries(mounts)) if (opts.driver) {
+		const driver = await import(builtinDrivers[opts.driver] || opts.driver).then((r) => r.default || r);
+		const processedOpts = replaceRuntimeValues({ ...opts }, runtime);
+		storage.mount(path, driver(processedOpts));
+	} else silgi.logger.warn(`No \`driver\` set for storage mount point "${path}".`);
+	return storage;
+}
+function useSilgiStorage(base = "/memory:cache") {
+	const silgi = useSilgi();
+	return base ? prefixStorage(silgi.storage, base) : silgi.storage;
+}
+async function generateStorageKey(params) {
+	const { url, input, keyGenerator, requestId, storageOptions } = params;
+	const cacheScopePrefix = storageOptions?.scope === "request" ? "req" : "global";
+	const parts = [cacheScopePrefix, url.raw].filter(Boolean);
+	if (storageOptions?.scope === "request") {
+		if (!requestId) throw createError({
+			statusCode: 400,
+			statusMessage: "Request ID is required for request-scoped cache",
+			data: {
+				requestId,
+				url,
+				input,
+				storageOptions,
+				keyGenerator
+			}
+		});
+		parts.push(requestId);
+	}
+	if (keyGenerator) {
+		const customKey = await Promise.resolve(keyGenerator(input));
+		parts.push(customKey);
+	} else parts.push(typeof input === "object" ? JSON.stringify(input) : String(input));
+	return Buffer.from(parts.join(":")).toString("base64");
+}
+
+//#endregion
+export { createStorage$1 as createStorage, generateStorageKey, useSilgiStorage };

package/dist/index.d.mts

@@ -1,6 +1,21 @@
-export { SilgiError, SilgiHttpEvent, autoImportTypes, createError, createEventStream, createResolver, createSchema, createService, createShared, createSilgi, createStorage, createWebSocket, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, getWebsocket, handleResponse, handler, isError, kHandled, kNotFound, middleware, replaceRuntimeValues, silgiCLICtx, silgiCtx, silgiFetch, storageMount, tryUseSilgi, tryUseSilgiCLI, updateRuntimeStorage, useRuntime, useSilgi, useSilgiCLI, useSilgiStorage } from './core/index.mjs';
-export { c as createMiddleware } from './shared/silgi.DTwQEdSr.mjs';
-import 'silgi/types';
-import 'srvx';
-import 'unctx';
-import 'unstorage';
+import { updateRuntimeStorage$1 as updateRuntimeStorage, useRuntime$1 as useRuntime } from "./core/context.mjs";
+import { createSilgi$1 as createSilgi } from "./core/createSilgi.mjs";
+import { SilgiError$1 as SilgiError, createError$1 as createError, isError$1 as isError } from "./core/error.mjs";
+import { SilgiHttpEvent$1 as SilgiHttpEvent } from "./core/event.mjs";
+import { handleResponse$1 as handleResponse, kHandled$1 as kHandled, kNotFound$1 as kNotFound } from "./core/response.mjs";
+import { getWebsocket$1 as getWebsocket, handler$1 as handler, middleware$1 as middleware, silgiFetch$1 as silgiFetch } from "./core/silgi.mjs";
+import { silgiCLICtx$1 as silgiCLICtx, tryUseSilgiCLI$1 as tryUseSilgiCLI, useSilgiCLI$1 as useSilgiCLI } from "./core/silgiApp.mjs";
+import { storageMount$1 as storageMount } from "./core/storage.mjs";
+import { silgiCtx$1 as silgiCtx, tryUseSilgi$1 as tryUseSilgi, useSilgi$1 as useSilgi } from "./core/unctx.mjs";
+import { createEventStream$1 as createEventStream } from "./core/utils/event-stream.mjs";
+import { getEvent$1 as getEvent, getEventContext$1 as getEventContext } from "./core/utils/event.mjs";
+import { deepMergeObjects$1 as deepMergeObjects } from "./core/utils/merge.mjs";
+import { createMiddleware$1 as createMiddleware } from "./core/utils/middleware.mjs";
+import { createResolver$3 as createResolver, getUrlPrefix$1 as getUrlPrefix } from "./core/utils/resolver.mjs";
+import { replaceRuntimeValues$1 as replaceRuntimeValues } from "./core/utils/runtime.mjs";
+import { createSchema$1 as createSchema } from "./core/utils/schema.mjs";
+import { createService$1 as createService, createWebSocket$1 as createWebSocket, defineServiceSetup$1 as defineServiceSetup } from "./core/utils/service.mjs";
+import { createShared$1 as createShared } from "./core/utils/shared.mjs";
+import { createStorage$1 as createStorage, useSilgiStorage$1 as useSilgiStorage } from "./core/utils/storage.mjs";
+import { autoImportTypes } from "./core/index.mjs";
+export { SilgiError, SilgiHttpEvent, autoImportTypes, createError, createEventStream, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, createWebSocket, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, getWebsocket, handleResponse, handler, isError, kHandled, kNotFound, middleware, replaceRuntimeValues, silgiCLICtx, silgiCtx, silgiFetch, storageMount, tryUseSilgi, tryUseSilgiCLI, updateRuntimeStorage, useRuntime, useSilgi, useSilgiCLI, useSilgiStorage };

package/dist/index.mjs

@@ -1,16 +1,22 @@
-export { SilgiError, SilgiHttpEvent, autoImportTypes, createError, createEventStream, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, createWebSocket, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, getWebsocket, handleResponse, handler, isError, kHandled, kNotFound, middleware, replaceRuntimeValues, silgiCtx, silgiFetch, storageMount, tryUseSilgi, updateRuntimeStorage, useRuntime, useSilgi, useSilgiStorage } from './core/index.mjs';
-export { s as silgiCLICtx, t as tryUseSilgiCLI, u as useSilgiCLI } from './_chunks/silgiApp.mjs';
-import 'node:async_hooks';
-import 'unctx';
-import '@standard-community/standard-json';
-import 'consola';
-import 'defu';
-import 'hookable';
-import 'rou3';
-import 'silgi/kit';
-import 'silgi/runtime';
-import 'node:buffer';
-import 'klona';
-import 'unstorage';
-import 'std-env';
-import 'srvx';
+import { silgiCLICtx, tryUseSilgiCLI, useSilgiCLI } from "./core/silgiApp.mjs";
+import { updateRuntimeStorage, useRuntime } from "./core/context.mjs";
+import { silgiCtx, tryUseSilgi, useSilgi } from "./core/unctx.mjs";
+import { SilgiError, createError, isError } from "./core/error.mjs";
+import { replaceRuntimeValues } from "./core/utils/runtime.mjs";
+import { createStorage, useSilgiStorage } from "./core/utils/storage.mjs";
+import { createSilgi } from "./core/createSilgi.mjs";
+import { SilgiHttpEvent } from "./core/event.mjs";
+import { handleResponse, kHandled, kNotFound } from "./core/response.mjs";
+import { createResolver$1 as createResolver, getUrlPrefix } from "./core/utils/resolver.mjs";
+import { getWebsocket, handler, middleware, silgiFetch } from "./core/silgi.mjs";
+import { storageMount } from "./core/storage.mjs";
+import { createEventStream } from "./core/utils/event-stream.mjs";
+import { getEvent, getEventContext } from "./core/utils/event.mjs";
+import { deepMergeObjects } from "./core/utils/merge.mjs";
+import { createMiddleware } from "./core/utils/middleware.mjs";
+import { createSchema } from "./core/utils/schema.mjs";
+import { createService, createWebSocket, defineServiceSetup } from "./core/utils/service.mjs";
+import { createShared } from "./core/utils/shared.mjs";
+import { autoImportTypes } from "./core/index.mjs";
+
+export { SilgiError, SilgiHttpEvent, autoImportTypes, createError, createEventStream, createMiddleware, createResolver, createSchema, createService, createShared, createSilgi, createStorage, createWebSocket, deepMergeObjects, defineServiceSetup, getEvent, getEventContext, getUrlPrefix, getWebsocket, handleResponse, handler, isError, kHandled, kNotFound, middleware, replaceRuntimeValues, silgiCLICtx, silgiCtx, silgiFetch, storageMount, tryUseSilgi, tryUseSilgiCLI, updateRuntimeStorage, useRuntime, useSilgi, useSilgiCLI, useSilgiStorage };

package/dist/kit/add/add-commands.d.mts

@@ -0,0 +1,6 @@
+import { Commands } from "silgi/types";
+
+//#region src/kit/add/add-commands.d.ts
+declare function addCommands(data: Commands | Commands[]): Promise<void>;
+//#endregion
+export { addCommands as addCommands$1 };

package/dist/kit/add/add-commands.mjs

@@ -0,0 +1,12 @@
+import { useSilgiCLI } from "../../core/silgiApp.mjs";
+import { toArray } from "../utils.mjs";
+
+//#region src/kit/add/add-commands.ts
+async function addCommands(data) {
+	useSilgiCLI().hook("prepare:commands", (commads) => {
+		commads.push(...toArray(data));
+	});
+}
+
+//#endregion
+export { addCommands };

package/dist/kit/add/add-core-file.d.mts

@@ -0,0 +1,9 @@
+import { SilgiCLIHooks } from "silgi/types";
+
+//#region src/kit/add/add-core-file.d.ts
+declare function addCoreFile(data: {
+  before?: SilgiCLIHooks["before:core.ts"];
+  after?: SilgiCLIHooks["after:core.ts"];
+}): Promise<void>;
+//#endregion
+export { addCoreFile as addCoreFile$1 };

package/dist/kit/add/add-core-file.mjs

@@ -0,0 +1,11 @@
+import { useSilgiCLI } from "../../core/silgiApp.mjs";
+
+//#region src/kit/add/add-core-file.ts
+async function addCoreFile(data) {
+	const silgi = useSilgiCLI();
+	if (data.before) silgi.hook("before:core.ts", data.before);
+	if (data.after) silgi.hook("after:core.ts", data.after);
+}
+
+//#endregion
+export { addCoreFile };

package/dist/kit/add/add-imports.d.mts

@@ -0,0 +1,14 @@
+import { GenImport } from "silgi/types";
+
+//#region src/kit/add/add-imports.d.ts
+declare function addImports(data?: {
+  imports?: GenImport[];
+  typeImports?: GenImport[];
+}): {
+  genImports: GenImport[];
+  genTypeImports: GenImport[];
+  addImportItem: (data: GenImport | GenImport[]) => void;
+  addImportItemType: (data: GenImport | GenImport[]) => void;
+};
+//#endregion
+export { addImports as addImports$1 };

package/dist/kit/add/add-imports.mjs

@@ -0,0 +1,56 @@
+import { toArray } from "silgi/kit";
+
+//#region src/kit/add/add-imports.ts
+function addImports$1(data) {
+	const genImports = [...data?.imports ?? []];
+	const genTypeImports = [...data?.typeImports ?? []];
+	function addImportItem(data$1) {
+		for (const item of toArray(data$1)) {
+			const isSpecifier = genImports.some((i) => i.specifier === item.specifier);
+			if (isSpecifier) {
+				const index = genImports.findIndex((i) => i.specifier === item.specifier);
+				if (index !== -1 && Array.isArray(genImports[index]?.imports)) {
+					genImports[index].imports ??= [];
+					genImports[index].imports.push(...toArray(item.imports));
+				} else if (index !== -1) genImports[index].imports = item.imports;
+			} else genImports.push({
+				specifier: item.specifier,
+				imports: item.imports,
+				options: item.options
+			});
+		}
+	}
+	function addImportItemType(data$1) {
+		for (const item of toArray(data$1)) {
+			const isSpecifier = genTypeImports.some((i) => i.specifier === item.specifier);
+			if (isSpecifier) {
+				const index = genTypeImports.findIndex((i) => i.specifier === item.specifier);
+				if (index !== -1 && genTypeImports[index] && Array.isArray(genTypeImports[index].imports)) {
+					genTypeImports[index].imports ??= [];
+					const newImports = toArray(item.imports);
+					for (const newImport of newImports) {
+						const isDuplicate = genTypeImports[index].imports.some((existingImport) => {
+							if (typeof existingImport === "string" && typeof newImport === "string") return existingImport === newImport;
+							else if (typeof existingImport === "object" && typeof newImport === "object") return existingImport.name === newImport.name && existingImport.as === newImport.as;
+							return false;
+						});
+						if (!isDuplicate) genTypeImports[index].imports.push(newImport);
+					}
+				} else if (index !== -1 && genTypeImports[index]) genTypeImports[index].imports = item.imports;
+			} else genTypeImports.push({
+				specifier: item.specifier,
+				imports: item.imports,
+				options: item.options
+			});
+		}
+	}
+	return {
+		genImports,
+		genTypeImports,
+		addImportItem,
+		addImportItemType
+	};
+}
+
+//#endregion
+export { addImports$1 as addImports };

package/dist/kit/add/add-npm.d.mts

@@ -0,0 +1,14 @@
+//#region src/kit/add/add-npm.d.ts
+declare function addNPMPackage(data: {
+  name: string;
+  version?: string;
+  isDev?: boolean;
+  when?: boolean;
+}[] | {
+  name: string;
+  version?: string;
+  isDev?: boolean;
+  when?: boolean;
+}): Promise<void>;
+//#endregion
+export { addNPMPackage as addNPMPackage$1 };

package/dist/kit/add/add-npm.mjs

@@ -0,0 +1,23 @@
+import { useSilgiCLI } from "../../core/silgiApp.mjs";
+import { toArray } from "../utils.mjs";
+import { execSync } from "node:child_process";
+
+//#region src/kit/add/add-npm.ts
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function addNPMPackage(data) {
+	const silgi = useSilgiCLI();
+	if (silgi.options.commandType !== "install") return;
+	for (const item of toArray(data)) {
+		if (item.when === false) continue;
+		const getPackageVersion = execSync(`pnpm info ${item.name} version`, { encoding: "utf-8" });
+		silgi.logger.withTag("add-npm").success("Checking package version", item.name, getPackageVersion.trim());
+		let version = item.version || getPackageVersion.trim();
+		version = `^${version}`;
+		if (item.isDev) silgi.options.installPackages.devDependencies[item.name] = version;
+		else silgi.options.installPackages.dependencies[item.name] = version;
+		await delay(50);
+	}
+}
+
+//#endregion
+export { addNPMPackage };

package/dist/kit/define.d.mts

@@ -0,0 +1,28 @@
+import { PresetName } from "silgi/presets";
+import { DefineFrameworkOptions } from "silgi/types";
+
+//#region src/kit/define.d.ts
+
+/**
+* Define a framework handler with proper type safety using a fluent API
+*
+* @param preset The framework preset to use
+* @example
+* ```ts
+* const h3Handler = defineFramework('h3').build(async (options) => {
+*   // Type-safe access to h3 router
+*   const router = options.framework
+*   // Implementation here with async/await support
+*   await someAsyncOperation()
+* })
+* ```
+*/
+declare function defineFramework<T extends PresetName>(preset: T): {
+  /**
+  * Build the framework handler
+  * @param callback The callback function that will receive typed options (can be async)
+  */
+  build(callback: (options: DefineFrameworkOptions<T>) => void | Promise<void>): (options: DefineFrameworkOptions<T>) => Promise<void>;
+};
+//#endregion
+export { defineFramework as defineFramework$1 };

package/dist/kit/define.mjs

@@ -0,0 +1,25 @@
+//#region src/kit/define.ts
+/**
+* Define a framework handler with proper type safety using a fluent API
+*
+* @param preset The framework preset to use
+* @example
+* ```ts
+* const h3Handler = defineFramework('h3').build(async (options) => {
+*   // Type-safe access to h3 router
+*   const router = options.framework
+*   // Implementation here with async/await support
+*   await someAsyncOperation()
+* })
+* ```
+*/
+function defineFramework(preset) {
+	return { build(callback) {
+		return async function handler(options) {
+			await callback(options);
+		};
+	} };
+}
+
+//#endregion
+export { defineFramework };

package/dist/kit/errors.d.mts

@@ -0,0 +1,6 @@
+import { SilgiCLI } from "silgi/types";
+
+//#region src/kit/errors.d.ts
+declare function hasError(type: SilgiCLI["errors"][0]["type"], silgi?: SilgiCLI): boolean;
+//#endregion
+export { hasError as hasError$1 };

package/dist/kit/errors.mjs

@@ -0,0 +1,11 @@
+import { tryUseSilgiCLI } from "silgi";
+
+//#region src/kit/errors.ts
+function hasError(type, silgi) {
+	silgi = silgi ?? tryUseSilgiCLI() ?? void 0;
+	if (silgi && silgi.errors.some((error) => error.type === type)) return true;
+	return false;
+}
+
+//#endregion
+export { hasError };

package/dist/kit/esm.d.mts

@@ -0,0 +1,11 @@
+//#region src/kit/esm.d.ts
+declare function directoryToURL(dir: string): URL;
+/**
+* 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>;
+//#endregion
+export { directoryToURL as directoryToURL$1, tryResolveModule as tryResolveModule$1 };

package/dist/kit/esm.mjs

@@ -0,0 +1,21 @@
+import { resolvePath } from "mlly";
+import { pathToFileURL } from "node:url";
+
+//#region src/kit/esm.ts
+function directoryToURL(dir) {
+	return pathToFileURL(`${dir}/`);
+}
+/**
+* Resolve a module from a given root path using an algorithm patterned on
+* the upcoming `import.meta.resolve`. It returns a file URL
+*
+* @internal
+*/
+async function tryResolveModule(id, url = import.meta.url) {
+	try {
+		return await resolvePath(id, { url });
+	} catch {}
+}
+
+//#endregion
+export { directoryToURL, tryResolveModule };

package/dist/kit/fs.d.mts

@@ -0,0 +1,7 @@
+import { Buffer } from "node:buffer";
+
+//#region src/kit/fs.d.ts
+declare function writeFile(file: string, contents: Buffer | string, log?: boolean): Promise<void>;
+declare function isDirectory(path: string): Promise<boolean>;
+//#endregion
+export { isDirectory as isDirectory$1, writeFile as writeFile$1 };

package/dist/kit/fs.mjs

@@ -0,0 +1,23 @@
+import { prettyPath } from "./path.mjs";
+import { dirname } from "pathe";
+import { useSilgiCLI } from "silgi";
+import fsp from "node:fs/promises";
+
+//#region src/kit/fs.ts
+async function writeFile$1(file, contents, log = false) {
+	const silgi = useSilgiCLI();
+	if (silgi.errors.length) return;
+	await fsp.mkdir(dirname(file), { recursive: true });
+	await fsp.writeFile(file, contents, typeof contents === "string" ? "utf8" : void 0);
+	if (log) silgi.logger.info("Generated", prettyPath(file));
+}
+async function isDirectory(path) {
+	try {
+		return (await fsp.stat(path)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+export { isDirectory, writeFile$1 as writeFile };

package/dist/kit/function-utils.d.mts

@@ -0,0 +1,27 @@
+//#region src/kit/function-utils.d.ts
+/**
+* Interface for function call configurations
+*/
+interface FunctionConfig {
+  name: string;
+  args: any[];
+}
+declare function createFunctionConfigs(configs: FunctionConfig[]): FunctionConfig[];
+/**
+* Generic utility function to create function call configurations
+* @param name Function name
+* @param args Function arguments (default empty object)
+* @returns Structured function configuration
+*/
+declare function createFunction(name: string, args?: any): FunctionConfig;
+/**
+* Format function calls with consistent indentation for code generation
+* @param configs Array of function configurations
+* @param indentation Spaces for indentation (default 4)
+* @param specialVars Array of variable names that should be treated as code references not strings
+* @param deduplicateArgs Whether to extract duplicate arguments into variables (default false)
+* @returns Formatted string of function calls
+*/
+declare function formatFunctions(configs: FunctionConfig[], indentation?: number, specialVars?: string[], deduplicateArgs?: boolean): string;
+//#endregion
+export { FunctionConfig, createFunction as createFunction$1, createFunctionConfigs as createFunctionConfigs$1, formatFunctions as formatFunctions$1 };

package/dist/kit/function-utils.mjs

@@ -0,0 +1,75 @@
+//#region src/kit/function-utils.ts
+function createFunctionConfigs(configs) {
+	return configs;
+}
+/**
+* Generic utility function to create function call configurations
+* @param name Function name
+* @param args Function arguments (default empty object)
+* @returns Structured function configuration
+*/
+function createFunction(name, args = {}) {
+	return {
+		name,
+		args: Object.keys(args).length > 0 ? [args] : []
+	};
+}
+/**
+* Format function calls with consistent indentation for code generation
+* @param configs Array of function configurations
+* @param indentation Spaces for indentation (default 4)
+* @param specialVars Array of variable names that should be treated as code references not strings
+* @param deduplicateArgs Whether to extract duplicate arguments into variables (default false)
+* @returns Formatted string of function calls
+*/
+function formatFunctions(configs, indentation = 4, specialVars = [], deduplicateArgs = false) {
+	const indent = " ".repeat(indentation);
+	const argMap = new Map();
+	const argVarDeclarations = [];
+	let argCounter = 0;
+	if (deduplicateArgs) configs.forEach((config) => {
+		if (config.args.length > 0) {
+			const argStr = JSON.stringify(config.args[0]);
+			if (!argMap.has(argStr) && argStr.length > 20) {
+				const varName = `args${argCounter++}`;
+				argMap.set(argStr, varName);
+				argVarDeclarations.push(`const ${varName} = ${processArgString(argStr, specialVars, indentation)}`);
+			}
+		}
+	});
+	function processArgString(argStr, specialVars$1, indentLevel) {
+		const parsed = JSON.parse(argStr);
+		const prettified = formatObjectWithIndentation(parsed, indentLevel);
+		let processed = prettified;
+		specialVars$1.forEach((varName) => {
+			processed = processed.replace(new RegExp(`"${varName}"`, "g"), varName);
+		});
+		return processed;
+	}
+	function formatObjectWithIndentation(obj, indentLevel) {
+		const baseIndent = " ".repeat(indentLevel);
+		const innerIndent = " ".repeat(indentLevel + 2);
+		if (typeof obj !== "object" || obj === null) return JSON.stringify(obj);
+		if (Array.isArray(obj)) {
+			if (obj.length === 0) return "[]";
+			const items = obj.map((item) => `${innerIndent}${formatObjectWithIndentation(item, indentLevel + 2)}`).join(",\n");
+			return `[\n${items}\n${baseIndent}]`;
+		}
+		if (Object.keys(obj).length === 0) return "{}";
+		const entries = Object.entries(obj).map(([key, value]) => {
+			return `${innerIndent}${key}: ${formatObjectWithIndentation(value, indentLevel + 2)}`;
+		}).join(",\n");
+		return `{\n${entries}\n${baseIndent}}`;
+	}
+	const formattedCalls = configs.map((config) => {
+		if (config.args.length === 0) return `${indent}${config.name}()`;
+		const argStr = JSON.stringify(config.args[0]);
+		if (deduplicateArgs && argMap.has(argStr) && argStr.length > 20) return `${indent}${config.name}(${argMap.get(argStr)})`;
+		else return `${indent}${config.name}(${processArgString(argStr, specialVars, indentation)})`;
+	}).join(",\n");
+	if (deduplicateArgs && argVarDeclarations.length > 0) return `${argVarDeclarations.join(";\n")};\n\n${formattedCalls}`;
+	return formattedCalls;
+}
+
+//#endregion
+export { createFunction, createFunctionConfigs, formatFunctions };

package/dist/kit/gen.d.mts

@@ -0,0 +1,5 @@
+//#region src/kit/gen.d.ts
+declare function genEnsureSafeVar(name: string | any): string;
+declare function getAllEntries(obj: object): [string, any][];
+//#endregion
+export { genEnsureSafeVar as genEnsureSafeVar$1, getAllEntries as getAllEntries$1 };

package/dist/kit/gen.mjs

@@ -0,0 +1,26 @@
+import { genObjectFromRaw, genObjectFromRawEntries, genObjectFromValues, genString } from "knitwork";
+
+//#region src/kit/gen.ts
+const reservedCode = new Set([
+	"process",
+	"global",
+	"runtime",
+	"runtimeConfig"
+]);
+function genEnsureSafeVar(name) {
+	if (typeof name !== "string") return genString(name);
+	for (const reserved of reservedCode) if (name === reserved || name.startsWith(`${reserved}.`)) return name;
+	return genString(name);
+}
+function getAllEntries(obj) {
+	return Object.entries(obj).map(([key, value]) => {
+		if (typeof value === "function") return [key, genObjectFromRaw(value)];
+		if (typeof value === "string") return [key, genEnsureSafeVar(value)];
+		if (typeof value === "object" && value !== null) if (Array.isArray(value)) return [key, genObjectFromValues(value.map((item) => typeof item === "object" && item !== null ? genObjectFromRawEntries(getAllEntries(item)) : item))];
+		else return [key, genObjectFromRawEntries(getAllEntries(value))];
+		return [key, value];
+	});
+}
+
+//#endregion
+export { genEnsureSafeVar, getAllEntries };

package/dist/kit/hash.d.mts

@@ -0,0 +1,4 @@
+//#region src/kit/hash.d.ts
+declare function hash(data: any): string;
+//#endregion
+export { hash as hash$1 };

package/dist/kit/hash.mjs

@@ -0,0 +1,10 @@
+import { camelCase } from "scule";
+import { hash } from "ohash";
+
+//#region src/kit/hash.ts
+function hash$1(data) {
+	return `_${camelCase(hash(data))}`;
+}
+
+//#endregion
+export { hash$1 as hash };