@povio/openapi-codegen-cli 2.0.8-rc.2 → 2.0.8-rc.20

package/README.md

@@ -69,6 +69,7 @@ yarn openapi-codegen generate --config my-config.ts
   --config                            Path to TS config file (default: 'openapi-codegen.config.ts')
   --input                             Path/URL to OpenAPI JSON/YAML document
   --output                            Output directory path (default: 'output')
+  --incremental                       Skip generation when OpenAPI and config are unchanged (default: true)
   --format                            Format the generated code using Oxfmt (default: true)
   --verbose                           Display detailed log messages during execution (default: false)
 
@@ -84,11 +85,16 @@ yarn openapi-codegen generate --config my-config.ts
   --tsPath                            (Requires `--importPath` to be 'ts') Typescript import path (default: '@/data')
   --removeOperationPrefixEndingWith   Remove operation name prefixes that end with the specified string (default: 'Controller_')
   --extractEnums                      Extract enums into separate Zod schemas (default: true)
+  --modelsInCommon                    Keep all schema declarations in defaultTag models and emit per-module proxy exports (default: false)
   --replaceOptionalWithNullish        Replace `.optional()` chains with `.nullish()` in generated Zod schemas (default: false)
 
   --axiosRequestConfig                Include Axios request config parameters in query hooks (default: false)
   --infiniteQueries                   Generate infinite queries for paginated API endpoints (default: false)
   --mutationEffects                   Add mutation effects options to mutation hooks (default: true)
+  --workspaceContext                  Allow generated hooks to resolve path/ACL params from OpenApiWorkspaceContext (default: false)
+  --inlineEndpoints                   Inline endpoint implementations into generated query files (default: false)
+  --inlineEndpointsExcludeModules     Comma-separated modules/tags to keep as separate API files while inlineEndpoints=true
+  --modelsOnly                        Generate only model files (default: false)
   --parseRequestParams                Add Zod parsing to API endpoints (default: true)
 
   --acl                               Generate ACL related files (default: true)
@@ -186,6 +192,63 @@ const config: OpenAPICodegenConfig = {
 export default config;
 ```
 
+### OpenApiWorkspaceContext (Path + ACL defaults)
+
+Enable `workspaceContext: true` in codegen config (or pass `--workspaceContext`) and wrap your app subtree with `OpenApiWorkspaceContext.Provider` if generated hooks frequently repeat workspace-scoped params (for example `officeId`).
+
+```tsx
+import { OpenApiWorkspaceContext } from "@povio/openapi-codegen-cli";
+// openapi-codegen.config.ts -> { workspaceContext: true }
+
+<OpenApiWorkspaceContext.Provider values={{ officeId: "office_123" }}>
+  <MyWorkspacePages />
+</OpenApiWorkspaceContext.Provider>;
+```
+
+Generated query/mutation hooks can then omit matching path/ACL params and resolve them from `OpenApiWorkspaceContext`.
+
+### Generation Modes
+
+You can control whether API endpoint files are emitted, inlined into query files, or skipped entirely.
+
+```ts
+import type { OpenAPICodegenConfig } from "@povio/openapi-codegen-cli";
+
+const config: OpenAPICodegenConfig = {
+  // 1) Default mode: separate *.api.ts files are generated
+  // 2) Inline mode: endpoint logic is generated inside *.queries.ts
+  // and can be used without separate api files:
+  // inlineEndpoints: true,
+  // inlineEndpointsExcludeModules: ["Users", "Billing"],
+  // 3) Models-only mode: generate only *.models.ts files
+  // modelsOnly: true,
+  // 4) Keep all model declarations in common.models and generate per-module model proxies
+  // modelsInCommon: true,
+};
+```
+
+### Vite Plugin
+
+You can run codegen directly from Vite config (without CLI config file):
+
+```ts
+import { defineConfig } from "vite";
+import { openApiCodegen } from "@povio/openapi-codegen-cli/vite";
+
+export default defineConfig({
+  plugins: [
+    openApiCodegen({
+      input: "./openapi.yaml",
+      output: "./src/data",
+      inlineEndpoints: true,
+      incremental: true,
+    }),
+  ],
+});
+```
+
+The plugin runs on both `vite serve` and `vite build`, and watches local OpenAPI files in dev mode.
+
 ### Enums
 
 If you're using Enums in your backend DTOs with `@Expose()` and `@IsEnum`, they may still not appear correctly in the OpenAPI schema unless you also provide both `enum` **and** `enumName` to `@ApiProperty`.

package/dist/acl.d.mts

@@ -0,0 +1,59 @@
+import { r as ErrorHandler } from "./error-handling-CXeVTk1T.mjs";
+import * as react from "react";
+import { PropsWithChildren } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { AbilityTuple, PureAbility, RawRuleOf, Subject } from "@casl/ability";
+import { PackRule } from "@casl/ability/extra";
+import { BoundCanProps } from "@casl/react";
+
+//#region src/lib/acl/appAbility.types.d.ts
+type AppAbilities = AbilityTuple<string, Subject>;
+type AppAbility = PureAbility<AppAbilities>;
+//#endregion
+//#region src/lib/acl/ability.context.d.ts
+declare namespace AbilityContext {
+  export const Consumer: react.Consumer<AppAbility>;
+  interface ProviderProps {
+    user?: {
+      aclRules?: PackRule<RawRuleOf<AppAbility>>[];
+    } | null;
+  }
+  export const Provider: ({
+    children
+  }: PropsWithChildren<ProviderProps>) => react_jsx_runtime0.JSX.Element;
+  export const useAbility: <TAppAbilities extends AppAbilities = AppAbilities>() => PureAbility<TAppAbilities>;
+  export {};
+}
+//#endregion
+//#region src/lib/acl/AclGuard.d.ts
+interface AclGuardProps<TAppAbilities extends AppAbilities = AppAbilities> {
+  canUse: TAppAbilities;
+  redirectTo?: string;
+}
+declare const createAclGuard: <TAppAbilities extends AppAbilities = AppAbilities>() => ({
+  canUse,
+  redirectTo,
+  children
+}: PropsWithChildren<AclGuardProps<TAppAbilities>>) => react.ReactNode;
+//#endregion
+//#region src/lib/acl/Can.d.ts
+type CanAbility = PureAbility<AbilityTuple<AppAbilities[0], AppAbilities[1]>>;
+type CanProps<TAppAbilities extends AppAbilities = AppAbilities> = {
+  use: TAppAbilities;
+} & Omit<BoundCanProps<CanAbility>, "do" | "I" | "on" | "a" | "an" | "this">;
+declare const Can: <TAppAbilities extends AppAbilities = AppAbilities>({
+  use,
+  ...props
+}: CanProps<TAppAbilities>) => react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/lib/acl/useAclCheck.d.ts
+interface UseAclCheckProps {
+  errorHandler?: ErrorHandler<never>;
+}
+declare function useAclCheck<TAppAbilities extends AppAbilities = AppAbilities>({
+  errorHandler
+}?: UseAclCheckProps): {
+  checkAcl: (appAbility: TAppAbilities) => void;
+};
+//#endregion
+export { AbilityContext, type AppAbilities, type AppAbility, Can, createAclGuard, useAclCheck };

package/dist/acl.mjs

@@ -1,8 +1,74 @@
-import { AbilityContext } from "./lib/acl/ability.context.mjs";
-import { createAclGuard } from "./lib/acl/AclGuard.mjs";
-import { Can } from "./lib/acl/Can.mjs";
-export {
-  AbilityContext,
-  Can,
-  createAclGuard
+import { r as SharedErrorHandler } from "./error-handling-DkPY7Asf.mjs";
+import { n as OpenApiRouter, t as AuthContext } from "./auth.context-Bu5KW2sI.mjs";
+import { createContext, useCallback, useEffect, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+import { AbilityBuilder, createMongoAbility } from "@casl/ability";
+import { unpackRules } from "@casl/ability/extra";
+import { createContextualCan, useAbility } from "@casl/react";
+
+//#region src/lib/acl/ability.context.tsx
+let AbilityContext;
+(function(_AbilityContext) {
+	const createAppAbilityBuilder = () => new AbilityBuilder(createMongoAbility);
+	const initialAppAbility = createAppAbilityBuilder().build();
+	const Context = createContext({});
+	const { Consumer } = Context;
+	_AbilityContext.Consumer = Consumer;
+	_AbilityContext.Provider = ({ children }) => {
+		const [ability, setAbility] = useState(initialAppAbility);
+		const { user } = AuthContext.useAuth();
+		useEffect(() => {
+			if (!user || !("aclRules" in user)) return;
+			const { can, build } = createAppAbilityBuilder();
+			const packedRules = user.aclRules;
+			unpackRules(packedRules).forEach(({ action, subject, conditions }) => {
+				can(action, subject, conditions);
+			});
+			setAbility(build());
+		}, [user]);
+		return /* @__PURE__ */ jsx(Context.Provider, {
+			value: ability,
+			children
+		});
+	};
+	_AbilityContext.useAbility = () => {
+		return useAbility(Context);
+	};
+})(AbilityContext || (AbilityContext = {}));
+
+//#endregion
+//#region src/lib/acl/AclGuard.tsx
+const createAclGuard = () => ({ canUse, redirectTo = "/", children }) => {
+	const ability = AbilityContext.useAbility();
+	const { replace } = OpenApiRouter.useRouter();
+	if (!ability.can(canUse[0], canUse[1])) {
+		replace(redirectTo);
+		return null;
+	}
+	return children;
 };
+
+//#endregion
+//#region src/lib/acl/Can.tsx
+const ContextualCan = createContextualCan(AbilityContext.Consumer);
+const Can = ({ use, ...props }) => {
+	const [action, subject] = use;
+	return /* @__PURE__ */ jsx(ContextualCan, {
+		...props,
+		do: action,
+		on: subject
+	});
+};
+
+//#endregion
+//#region src/lib/acl/useAclCheck.ts
+function useAclCheck({ errorHandler } = {}) {
+	const ability = AbilityContext.useAbility();
+	return { checkAcl: useCallback((appAbility) => {
+		const can = ability.can;
+		if (!can(...appAbility)) (errorHandler ?? SharedErrorHandler).rethrowError(/* @__PURE__ */ new Error("ACL check failed"));
+	}, [ability, errorHandler]) };
+}
+
+//#endregion
+export { AbilityContext, Can, createAclGuard, useAclCheck };

package/dist/auth.context-Bu5KW2sI.mjs

@@ -0,0 +1,59 @@
+import { createContext, use, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/lib/config/router.context.tsx
+let OpenApiRouter;
+(function(_OpenApiRouter) {
+	const Context = createContext(null);
+	_OpenApiRouter.Provider = ({ children, replace }) => {
+		return /* @__PURE__ */ jsx(Context, {
+			value: useMemo(() => ({ replace }), [replace]),
+			children
+		});
+	};
+	_OpenApiRouter.useRouter = () => {
+		const context = use(Context);
+		if (!context) throw new Error("useRouter must be used within an OpenApiRouter.Provider");
+		return context;
+	};
+})(OpenApiRouter || (OpenApiRouter = {}));
+
+//#endregion
+//#region src/lib/auth/auth.context.tsx
+let AuthContext;
+(function(_AuthContext) {
+	const Context = createContext({});
+	_AuthContext.Provider = ({ isAuthenticated, isInitializing, logout, updateTokens, accessToken, user, userPromise, routes, loadingState, children }) => {
+		const value = useMemo(() => ({
+			isAuthenticated,
+			isInitializing,
+			logout,
+			updateTokens,
+			accessToken,
+			user,
+			userPromise,
+			routes,
+			loadingState
+		}), [
+			isAuthenticated,
+			isInitializing,
+			logout,
+			updateTokens,
+			accessToken,
+			user,
+			userPromise,
+			routes,
+			loadingState
+		]);
+		return /* @__PURE__ */ jsx(Context.Provider, {
+			value,
+			children
+		});
+	};
+	_AuthContext.useAuth = () => {
+		return use(Context);
+	};
+})(AuthContext || (AuthContext = {}));
+
+//#endregion
+export { OpenApiRouter as n, AuthContext as t };

package/dist/config-BHkVxL6S.d.mts

@@ -0,0 +1,6 @@
+import { t as GenerateOptions } from "./options-BNqkO_OS.mjs";
+
+//#region src/generators/types/config.d.ts
+type OpenAPICodegenConfig = Partial<GenerateOptions>;
+//#endregion
+export { OpenAPICodegenConfig as t };

package/dist/error-handling-CXeVTk1T.d.mts

@@ -0,0 +1,38 @@
+import { TFunction } from "i18next";
+
+//#region src/lib/rest/error-handling.d.ts
+type GeneralErrorCodes = "DATA_VALIDATION_ERROR" | "NETWORK_ERROR" | "CANCELED_ERROR" | "INTERNAL_ERROR" | "UNKNOWN_ERROR";
+declare class ApplicationException<CodeT> extends Error {
+  code: CodeT;
+  serverMessage: string | null;
+  constructor(message: string, code: CodeT, serverMessage: string | null);
+}
+interface ErrorEntry<CodeT> {
+  code: CodeT;
+  condition?: (error: unknown) => boolean;
+  getMessage: (t: TFunction, error: unknown) => string;
+}
+interface ErrorHandlerOptions<CodeT extends string> {
+  entries: ErrorEntry<CodeT>[];
+  t?: TFunction;
+  onRethrowError?: (error: unknown, exception: ApplicationException<CodeT | GeneralErrorCodes>) => void;
+}
+declare class ErrorHandler<CodeT extends string> {
+  entries: ErrorEntry<CodeT | GeneralErrorCodes>[];
+  private t;
+  private onRethrowError?;
+  constructor({
+    entries,
+    t,
+    onRethrowError
+  }: ErrorHandlerOptions<CodeT>);
+  private matchesEntry;
+  setTranslateFunction(t: TFunction): void;
+  rethrowError(error: unknown): ApplicationException<CodeT | GeneralErrorCodes>;
+  getError(error: unknown): ApplicationException<CodeT | GeneralErrorCodes> | null;
+  getErrorCode(error: unknown): CodeT | GeneralErrorCodes | null;
+  static getErrorMessage(error: unknown, fallbackToUnknown?: boolean): string | null;
+}
+declare const SharedErrorHandler: ErrorHandler<never>;
+//#endregion
+export { GeneralErrorCodes as a, ErrorHandlerOptions as i, ErrorEntry as n, SharedErrorHandler as o, ErrorHandler as r, ApplicationException as t };

package/dist/error-handling-DkPY7Asf.mjs

@@ -0,0 +1,187 @@
+import { isAxiosError, isCancel } from "axios";
+import { z } from "zod";
+import i18next from "i18next";
+
+//#region src/lib/assets/locales/en/translation.json
+var translation_default$1 = { openapi: { "sharedErrors": {
+	"dataValidation": "An error occurred while validating the data",
+	"internalError": "An internal error occurred. This is most likely a bug on our end. Please try again later.",
+	"networkError": "A network error occurred. Are you connected to the internet?",
+	"canceledError": "The request was canceled.",
+	"unknownError": "An unknown error occurred. Please try again later.",
+	"unknownErrorWithCode": "An unknown error occurred. Error code: \"{{code}}\""
+} } };
+
+//#endregion
+//#region src/lib/assets/locales/sl/translation.json
+var translation_default = { openapi: { "sharedErrors": {
+	"dataValidation": "Pri preverjanju podatkov je prišlo do napake",
+	"internalError": "Prišlo je do notranje napake.",
+	"networkError": "Prišlo je do napake v omrežju.",
+	"canceledError": "Zahteva je bila preklicana.",
+	"unknownError": "Prišlo je do neznane napake.",
+	"unknownErrorWithCode": "Prišlo je do neznane napake. Koda napake: \"{{code}}\""
+} } };
+
+//#endregion
+//#region src/lib/config/i18n.ts
+const ns = "openapi";
+const resources = {
+	en: { [ns]: translation_default$1 },
+	sl: { [ns]: translation_default }
+};
+const defaultLanguage = "en";
+const i18n = i18next.createInstance();
+i18n.init({
+	compatibilityJSON: "v4",
+	lng: defaultLanguage,
+	fallbackLng: defaultLanguage,
+	resources,
+	ns: Object.keys(resources.en),
+	defaultNS: ns,
+	interpolation: { escapeValue: false }
+});
+const defaultT = i18n.t.bind(i18n);
+
+//#endregion
+//#region src/lib/rest/rest.utils.ts
+let RestUtils;
+(function(_RestUtils) {
+	_RestUtils.extractServerResponseCode = (e) => {
+		if (e instanceof z.ZodError) return "validation-exception";
+		if (!isAxiosError(e)) return null;
+		if (!e.response) return null;
+		const data = e.response.data;
+		if (typeof data?.code === "string") return data.code;
+		return null;
+	};
+	_RestUtils.doesServerErrorMessageContain = (e, text) => {
+		const message = extractServerErrorMessage(e);
+		if (message === null || message === void 0) return false;
+		return message.toLowerCase().includes(text.toLowerCase());
+	};
+	const extractServerErrorMessage = _RestUtils.extractServerErrorMessage = (e) => {
+		if (e instanceof z.ZodError) return e.message;
+		if (!isAxiosError(e)) return null;
+		if (!e.response) return null;
+		const data = e.response.data;
+		if (typeof data?.message === "string") return data.message;
+		return null;
+	};
+	_RestUtils.extractContentDispositionFilename = (headers) => {
+		const contentDisposition = headers["content-disposition"];
+		return contentDisposition ? /filename=["']?([^"';]+)/i.exec(contentDisposition)?.[1] : void 0;
+	};
+})(RestUtils || (RestUtils = {}));
+
+//#endregion
+//#region src/lib/rest/error-handling.ts
+var ApplicationException = class extends Error {
+	code;
+	serverMessage = null;
+	constructor(message, code, serverMessage) {
+		super(message);
+		this.code = code;
+		this.serverMessage = serverMessage;
+	}
+};
+var ErrorHandler = class {
+	entries = [];
+	t;
+	onRethrowError;
+	constructor({ entries, t = defaultT, onRethrowError }) {
+		this.t = t;
+		this.onRethrowError = onRethrowError;
+		const dataValidationError = {
+			code: "DATA_VALIDATION_ERROR",
+			condition: (e) => {
+				return e instanceof z.ZodError;
+			},
+			getMessage: () => this.t("openapi.sharedErrors.dataValidation")
+		};
+		const internalError = {
+			code: "INTERNAL_ERROR",
+			condition: (e) => {
+				if (isAxiosError(e)) return e.response?.status != null && e.response.status >= 500 && e.response.status < 600;
+				return false;
+			},
+			getMessage: () => this.t("openapi.sharedErrors.internalError")
+		};
+		const networkError = {
+			code: "NETWORK_ERROR",
+			condition: (e) => {
+				if (isAxiosError(e)) return e.code === "ERR_NETWORK";
+				return false;
+			},
+			getMessage: () => this.t("openapi.sharedErrors.networkError")
+		};
+		const canceledError = {
+			code: "CANCELED_ERROR",
+			condition: (e) => {
+				if (isCancel(e)) return true;
+				if (isAxiosError(e) && e.code === "ECONNABORTED") return true;
+				return false;
+			},
+			getMessage: () => this.t("openapi.sharedErrors.canceledError")
+		};
+		const unknownError = {
+			code: "UNKNOWN_ERROR",
+			condition: () => true,
+			getMessage: (_, e) => {
+				const code = RestUtils.extractServerResponseCode(e);
+				const serverMessage = RestUtils.extractServerErrorMessage(e);
+				if (code) {
+					let message = `Unknown error, message from server: ${code}`;
+					if (serverMessage) message += ` ${serverMessage}`;
+					return message;
+				}
+				return this.t("openapi.sharedErrors.unknownError");
+			}
+		};
+		this.entries = [
+			...entries,
+			dataValidationError,
+			internalError,
+			networkError,
+			canceledError,
+			unknownError
+		];
+	}
+	matchesEntry(error, entry, code) {
+		if (entry.condition) return entry.condition(error);
+		return code === entry.code;
+	}
+	setTranslateFunction(t) {
+		this.t = t;
+	}
+	rethrowError(error) {
+		const code = RestUtils.extractServerResponseCode(error);
+		const errorEntry = this.entries.find((entry) => this.matchesEntry(error, entry, code));
+		const serverMessage = RestUtils.extractServerErrorMessage(error);
+		const exception = new ApplicationException(errorEntry.getMessage(this.t, error), errorEntry.code, serverMessage);
+		this.onRethrowError?.(error, exception);
+		throw exception;
+	}
+	getError(error) {
+		if (error instanceof ApplicationException) return error;
+		return null;
+	}
+	getErrorCode(error) {
+		if (error instanceof ApplicationException) return error.code;
+		return null;
+	}
+	static getErrorMessage(error, fallbackToUnknown = true) {
+		if (typeof error === "string") return error;
+		if (error instanceof Error) return error.message;
+		if (error instanceof ApplicationException) {
+			if (error.serverMessage != null) return error.serverMessage;
+			return error.message;
+		}
+		if (fallbackToUnknown) return defaultT("openapi.sharedErrors.unknownError");
+		return null;
+	}
+};
+const SharedErrorHandler = new ErrorHandler({ entries: [] });
+
+//#endregion
+export { ns as a, RestUtils as i, ErrorHandler as n, resources as o, SharedErrorHandler as r, ApplicationException as t };

package/dist/generate.runner-DmZ5LVHf.mjs

@@ -0,0 +1,130 @@
+import { a as deepMerge, p as DEFAULT_GENERATE_OPTIONS, r as writeGenerateFileData, t as generateCodeFromOpenAPIDoc, x as Profiler } from "./generateCodeFromOpenAPIDoc-DZ5swy4U.mjs";
+import fs from "fs";
+import path from "path";
+import SwaggerParser from "@apidevtools/swagger-parser";
+
+//#region src/generators/core/resolveConfig.ts
+function resolveConfig({ fileConfig = {}, params: { excludeTags, inlineEndpointsExcludeModules, ...options } }) {
+	const resolvedConfig = deepMerge(DEFAULT_GENERATE_OPTIONS, fileConfig ?? {}, {
+		...options,
+		excludeTags: excludeTags?.split(","),
+		inlineEndpointsExcludeModules: inlineEndpointsExcludeModules?.split(",")
+	});
+	resolvedConfig.checkAcl = resolvedConfig.acl && resolvedConfig.checkAcl;
+	return resolvedConfig;
+}
+
+//#endregion
+//#region src/generators/run/generate.runner.ts
+const CACHE_FILE_NAME = ".openapi-codegen-cache.json";
+async function runGenerate({ fileConfig, params, profiler = new Profiler(process.env.OPENAPI_CODEGEN_PROFILE === "1") }) {
+	const config = profiler.runSync("config.resolve", () => resolveConfig({
+		fileConfig,
+		params: params ?? {}
+	}));
+	const openApiDoc = await getOpenApiDoc(config.input, profiler);
+	const openApiHash = hashString(stableStringify(openApiDoc));
+	const optionsHash = hashString(stableStringify(getCacheableConfig(config)));
+	const cacheFilePath = path.resolve(config.output, CACHE_FILE_NAME);
+	if (config.incremental) {
+		const cached = readCache(cacheFilePath);
+		if (cached && cached.openApiHash === openApiHash && cached.optionsHash === optionsHash) return {
+			skipped: true,
+			config,
+			stats: {
+				generatedFilesCount: 0,
+				generatedModulesCount: 0
+			}
+		};
+	}
+	const filesData = profiler.runSync("generate.total", () => generateCodeFromOpenAPIDoc(openApiDoc, config, profiler));
+	profiler.runSync("files.write", () => writeGenerateFileData(filesData));
+	const stats = getGenerateStats(filesData, config);
+	if (config.incremental) writeCache(cacheFilePath, {
+		openApiHash,
+		optionsHash
+	});
+	return {
+		skipped: false,
+		config,
+		stats
+	};
+}
+async function getOpenApiDoc(input, profiler) {
+	const parsedDoc = await profiler.runAsync("openapi.parse", async () => await SwaggerParser.parse(input));
+	if (!profiler.runSync("openapi.detectExternalRefs", () => hasExternalRef(parsedDoc))) return parsedDoc;
+	return await profiler.runAsync("openapi.bundle", async () => await SwaggerParser.bundle(input));
+}
+function hasExternalRef(value) {
+	const stack = [value];
+	const visited = /* @__PURE__ */ new Set();
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current || typeof current !== "object") continue;
+		if (visited.has(current)) continue;
+		visited.add(current);
+		if ("$ref" in current && typeof current.$ref === "string" && !current.$ref.startsWith("#/")) return true;
+		for (const nested of Object.values(current)) if (nested && typeof nested === "object") stack.push(nested);
+	}
+	return false;
+}
+function getCacheableConfig(config) {
+	const { output, incremental, ...cacheableConfig } = config;
+	return cacheableConfig;
+}
+function readCache(filePath) {
+	if (!fs.existsSync(filePath)) return null;
+	try {
+		return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function writeCache(filePath, data) {
+	const dir = path.dirname(filePath);
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(data), "utf-8");
+}
+function hashString(input) {
+	let hash = 2166136261;
+	for (let i = 0; i < input.length; i += 1) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(16);
+}
+function stableStringify(input) {
+	if (input === null || typeof input !== "object") return JSON.stringify(input);
+	if (Array.isArray(input)) return `[${input.map((item) => stableStringify(item)).join(",")}]`;
+	const obj = input;
+	return `{${Object.keys(obj).sort((a, b) => a.localeCompare(b)).map((key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`).join(",")}}`;
+}
+function getGenerateStats(filesData, config) {
+	const generatedFilesCount = filesData.length;
+	if (generatedFilesCount === 0) return {
+		generatedFilesCount,
+		generatedModulesCount: 0
+	};
+	if (!config.splitByTags) return {
+		generatedFilesCount,
+		generatedModulesCount: 1
+	};
+	const moduleSuffixes = new Set(Object.values(config.configs).map((generateConfig) => generateConfig.outputFileNameSuffix).filter(Boolean));
+	const modules = /* @__PURE__ */ new Set();
+	for (const file of filesData) {
+		const segments = path.relative(config.output, file.fileName).split(path.sep).filter(Boolean);
+		if (segments.length < 2) continue;
+		const moduleName = segments[0];
+		const fileName = segments[segments.length - 1];
+		if (!fileName.startsWith(`${moduleName}.`)) continue;
+		const suffix = fileName.slice(moduleName.length + 1).replace(/\.tsx?$/, "");
+		if (moduleSuffixes.has(suffix)) modules.add(moduleName);
+	}
+	return {
+		generatedFilesCount,
+		generatedModulesCount: modules.size
+	};
+}
+
+//#endregion
+export { resolveConfig as n, runGenerate as t };