hono-takibi 0.7.1 → 0.7.3

package/dist/cli/app.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPISpec } from '../openapi/index.js';
+import type { Result } from '../result/index.js';
+export declare function app(openAPI: OpenAPISpec, output: `${string}.ts`, test: boolean, template: boolean, basePath?: string): Promise<Result<void, string>>;

package/dist/cli/app.js

@@ -0,0 +1,15 @@
+import path from 'node:path';
+import { ok, asyncAndThen } from '../result/index.js';
+import { readdir, writeFile } from '../fsp/index.js';
+import { fmt } from '../format/index.js';
+import { generateApp } from '../generator/zod-openapi-hono/app/index.js';
+import { zodOpenapiHonoHandler } from '../generator/zod-openapi-hono/handler/zod-openapi-hono-handler.js';
+export async function app(openAPI, output, test, template, basePath) {
+    if (!(template || !output.includes('/')))
+        return ok(undefined);
+    const dir = path.dirname(output);
+    return await asyncAndThen(await fmt(generateApp(openAPI, output, basePath)), async (appCode) => asyncAndThen(await readdir(dir), async (files) => {
+        const target = path.join(dir, files.includes('index.ts') ? 'main.ts' : 'index.ts');
+        return await asyncAndThen(await writeFile(target, appCode), async () => asyncAndThen(await zodOpenapiHonoHandler(openAPI, output, test), async () => ok(undefined)));
+    }));
+}

package/dist/cli/{helpers/flag-val-helper.d.ts → helper/flag-val.d.ts}

@@ -2,4 +2,4 @@
  * @param as - The array of strings to check for the flag
  * @param f - The flag to look for
  */
-export declare function flagValHelper(as: string[], f: string): string | undefined;
+export declare function flagVal(args: readonly string[], flag: string): string | undefined;

package/dist/cli/helper/flag-val.js

@@ -0,0 +1,10 @@
+/**
+ * @param as - The array of strings to check for the flag
+ * @param f - The flag to look for
+ */
+export function flagVal(args, flag) {
+    const idx = args.indexOf(flag);
+    if (idx !== -1 && args[idx + 1] && !args[idx + 1].startsWith('-'))
+        return args[idx + 1];
+    return undefined;
+}

package/dist/cli/helper/has-flag.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param args - The array of strings to check for the flag
+ * @param f
+ */
+export declare function hasFlag(args: readonly string[], f: string): boolean;

package/dist/cli/helper/has-flag.js

@@ -0,0 +1,7 @@
+/**
+ * @param args - The array of strings to check for the flag
+ * @param f
+ */
+export function hasFlag(args, f) {
+    return args.includes(f);
+}

package/dist/cli/helper/index.d.ts

@@ -0,0 +1,4 @@
+export { flagVal } from './flag-val.js';
+export { hasFlag } from './has-flag.js';
+export { setConfig } from './set-config.js';
+export { sliceArgs } from './slice-args.js';

package/dist/cli/helper/index.js

@@ -0,0 +1,4 @@
+export { flagVal } from './flag-val.js';
+export { hasFlag } from './has-flag.js';
+export { setConfig } from './set-config.js';
+export { sliceArgs } from './slice-args.js';

package/dist/cli/helper/set-config.d.ts

@@ -0,0 +1,21 @@
+import type { Config } from '../../config/index.js';
+import type { Result } from '../../result/types.js';
+import type { CliFlags } from '../types/index.js';
+/**
+ * Merge the base configuration with the CLI flags, returning a Result.
+ * @param base
+ * @param cli
+ * @returns Result<Config, string>
+ */
+export declare function setConfig(base: Config, cli: CliFlags): Result<{
+    schema: {
+        name: 'PascalCase' | 'camelCase';
+        export: boolean;
+    };
+    type: {
+        name: 'PascalCase' | 'camelCase';
+        export: boolean;
+    };
+    input: `${string}.yaml` | `${string}.json`;
+    output: `${string}.ts`;
+}, string>;

package/dist/cli/helper/set-config.js

@@ -0,0 +1,32 @@
+import { err } from '../../result/err.js';
+/**
+ * Merge the base configuration with the CLI flags, returning a Result.
+ * @param base
+ * @param cli
+ * @returns Result<Config, string>
+ */
+export function setConfig(base, cli) {
+    const input = cli.input ?? base.input;
+    const output = cli.output ?? base.output;
+    if (!(input || output)) {
+        return err('Usage: hono-takibi <input-file> -o <output-file>');
+    }
+    return {
+        ok: true,
+        value: {
+            ...base,
+            input,
+            output,
+            type: {
+                ...base.type,
+                export: cli.exportType ?? base.type.export ?? false,
+                name: cli.typeCase ?? base.type.name ?? 'PascalCase',
+            },
+            schema: {
+                ...base.schema,
+                export: cli.exportSchema ?? base.schema.export ?? false,
+                name: cli.schemaCase ?? base.schema.name ?? 'PascalCase',
+            },
+        },
+    };
+}

package/dist/cli/helper/slice-args.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @param argv - The command line arguments array
+ */
+export declare function sliceArgs(argv: readonly string[]): string[];

package/dist/cli/{helpers/slice-args-helper.js → helper/slice-args.js}

@@ -1,6 +1,6 @@
 /**
  * @param argv - The command line arguments array
  */
-export function sliceArgsHelper(argv) {
+export function sliceArgs(argv) {
     return argv.slice(2);
 }

package/dist/cli/index.d.ts

@@ -0,0 +1,4 @@
+import type { Result } from '../result/index.js';
+export declare function honoTakibi(): Promise<Result<{
+    message: string;
+}, string>>;

package/dist/cli/index.js

@@ -0,0 +1,38 @@
+import { ok, asyncAndThen } from '../result/index.js';
+import { sliceArgs } from './helper/slice-args.js';
+import { parseHelp } from './validator/parse-help.js';
+import { parseCliArgs } from './validator/parse-cli-args.js';
+import { getConfig } from '../config/index.js';
+import { setConfig } from './helper/set-config.js';
+import { takibi } from './takibi.js';
+const HELP_TEXT = `
+Usage:
+  hono-takibi <input.yaml|json> -o <routes.ts> [options]
+
+Options:
+  --export-type               Export generated type aliases
+
+  --export-schema             Export generated schema objects
+
+  --naming-case-type <PascalCase|camelCase>
+                              Casing for generated *type aliases*
+                              (default: PascalCase)
+
+  --naming-case-schema <PascalCase|camelCase>
+                              Casing for generated *schema objects*
+                              (default: PascalCase)
+
+  --template                  Generate an app file and handler stubs
+
+  --test                      Generate empty *.test.ts files for handlers
+
+  --base-path <path>          API prefix (e.g. /api)
+  
+  --help                      Show this help and exit
+`.trimStart();
+export async function honoTakibi() {
+    const args = sliceArgs(process.argv);
+    return parseHelp(args)
+        ? ok({ message: HELP_TEXT })
+        : await asyncAndThen(getConfig(), async (config) => asyncAndThen(parseCliArgs(args, config), async (cli) => asyncAndThen(setConfig(config, cli), async (finalConfig) => takibi(finalConfig, cli.template, cli.test, cli.basePath))));
+}

package/dist/cli/takibi.d.ts

@@ -0,0 +1,15 @@
+import type { Result } from '../result/types.js';
+export declare function takibi(config: {
+    schema: {
+        name: 'PascalCase' | 'camelCase';
+        export: boolean;
+    };
+    type: {
+        name: 'PascalCase' | 'camelCase';
+        export: boolean;
+    };
+    input: `${string}.yaml` | `${string}.json`;
+    output: `${string}.ts`;
+}, template: boolean, test: boolean, basePath?: string): Promise<Result<{
+    message: string;
+}, string>>;

package/dist/cli/takibi.js

@@ -0,0 +1,14 @@
+import path from 'node:path';
+import { ok, asyncAndThen } from '../result/index.js';
+import { fmt } from '../format/index.js';
+import { parseOpenAPI } from '../openapi/parse-openapi.js';
+import { zodOpenAPIHono } from '../generator/zod-openapi-hono/openapi/zod-openapi-hono.js';
+import { app } from './app.js';
+import { mkdir, writeFile } from '../fsp/index.js';
+export async function takibi(config, template, test, basePath) {
+    return await asyncAndThen(await parseOpenAPI(config.input), async (openAPI) => asyncAndThen(await fmt(zodOpenAPIHono(openAPI, config)), async (code) => asyncAndThen(await mkdir(path.dirname(config.output)), async () => asyncAndThen(await writeFile(config.output, code), async () => asyncAndThen(await app(openAPI, config.output, template, test, basePath), async () => ok({
+        message: template
+            ? 'Generated code and template files written'
+            : `Generated code written to ${config.output}`,
+    }))))));
+}

package/dist/cli/types/index.d.ts

@@ -1,22 +1,10 @@
-export type Naming = 'PascalCase' | 'camelCase';
-export type Ok<T> = {
-    ok: true;
-    value: T;
-};
-export type Err<E> = {
-    ok: false;
-    error: E;
-};
-export type Result<T, E = string> = Ok<T> | Err<E>;
-export declare const ok: <T>(v: T) => Ok<T>;
-export declare const err: <E>(e: E) => Err<E>;
 export type CliFlags = {
-    input: string;
-    output: string;
+    input: `${string}.yaml` | `${string}.json`;
+    output: `${string}.ts`;
     exportType?: boolean;
     exportSchema?: boolean;
-    typeCase?: Naming;
-    schemaCase?: Naming;
+    typeCase?: 'PascalCase' | 'camelCase';
+    schemaCase?: 'PascalCase' | 'camelCase';
     template: boolean;
     test: boolean;
     basePath?: string;

package/dist/cli/types/index.js

@@ -1,2 +1 @@
-export const ok = (v) => ({ ok: true, value: v });
-export const err = (e) => ({ ok: false, error: e });
+export {};

package/dist/cli/validator/index.d.ts

@@ -1,3 +1,6 @@
-export * from './ensure-io.js';
-export * from './parse-cli-args.js';
-export * from './parse-naming.js';
+export { parseCliArgs } from './parse-cli-args.js';
+export { parseHelp } from './parse-help.js';
+export { parseIO } from './parse-io.js';
+export { parseNaming } from './parse-naming.js';
+export { isYamlOrJson } from './is-yaml-or-json.js';
+export { isTs } from './is-ts.js';

package/dist/cli/validator/index.js

@@ -1,3 +1,6 @@
-export * from './ensure-io.js';
-export * from './parse-cli-args.js';
-export * from './parse-naming.js';
+export { parseCliArgs } from './parse-cli-args.js';
+export { parseHelp } from './parse-help.js';
+export { parseIO } from './parse-io.js';
+export { parseNaming } from './parse-naming.js';
+export { isYamlOrJson } from './is-yaml-or-json.js';
+export { isTs } from './is-ts.js';

package/dist/cli/validator/is-ts.d.ts

@@ -0,0 +1 @@
+export declare function isTs(o: string): o is `${string}.ts`;

package/dist/cli/validator/is-ts.js

@@ -0,0 +1,3 @@
+export function isTs(o) {
+    return o.endsWith('.ts') && !o.endsWith('.d.ts');
+}

package/dist/cli/validator/is-yaml-or-json.d.ts

@@ -0,0 +1 @@
+export declare function isYamlOrJson(i: string): i is `${string}.yaml` | `${string}.json`;

package/dist/cli/validator/is-yaml-or-json.js

@@ -0,0 +1,3 @@
+export function isYamlOrJson(i) {
+    return i.endsWith('.yaml') || i.endsWith('.json');
+}

package/dist/cli/validator/parse-cli-args.d.ts

@@ -1,10 +1,11 @@
-import type { CliFlags, Result } from '../types/index.js';
+import type { Result } from '../../result/index.js';
+import type { CliFlags } from '../types/index.js';
 /**
  * Parses command line arguments into a structured format.
- * @param argv - The command line arguments.
+ * @param args - The command line arguments.
  * @returns A Result containing the parsed flags or an error message.
  */
-export declare function parseCliArgs(argv: string[], config: {
-    input?: string;
-    output?: string;
-}): Result<CliFlags>;
+export declare function parseCliArgs(args: readonly string[], config: {
+    input?: `${string}.yaml` | `${string}.json`;
+    output?: `${string}.ts`;
+}): Result<CliFlags, string>;

package/dist/cli/validator/parse-cli-args.js

@@ -1,62 +1,21 @@
-import { flagValHelper } from '../helpers/flag-val-helper.js';
-import { hasFlagHelper } from '../helpers/has-flag-helper.js';
-import { sliceArgsHelper } from '../helpers/slice-args-helper.js';
-import { ensureIO } from './ensure-io.js';
-import { parseNaming } from './parse-naming.js';
-import { ok, err } from '../types/index.js';
-const HELP_TEXT = `
-Usage:
-  hono-takibi <input.yaml|json> -o <routes.ts> [options]
-
-Options:
-  --export-type               Export generated type aliases
-
-  --export-schema             Export generated schema objects
-
-  --naming-case-type <PascalCase|camelCase>
-                              Casing for generated *type aliases*
-                              (default: PascalCase)
-
-  --naming-case-schema <PascalCase|camelCase>
-                              Casing for generated *schema objects*
-                              (default: PascalCase)
-
-  --template                  Generate an app file and handler stubs
-
-  --test                      Generate empty *.test.ts files for handlers
-
-  --base-path <path>          API prefix (e.g. /api)
-  
-  --help                      Show this help and exit
-`.trimStart();
+import { flagVal, hasFlag } from '../helper/index.js';
+import { parseIO, parseNaming } from './index.js';
+import { ok, andThen } from '../../result/index.js';
 /**
  * Parses command line arguments into a structured format.
- * @param argv - The command line arguments.
+ * @param args - The command line arguments.
  * @returns A Result containing the parsed flags or an error message.
  */
-export function parseCliArgs(argv, config) {
-    const args = sliceArgsHelper(argv);
-    if (args.includes('--help')) {
-        return err(HELP_TEXT);
-    }
-    const io = ensureIO(args, config);
-    if (!io.ok)
-        return err(io.error);
-    const tRes = parseNaming(flagValHelper(args, '--naming-case-type'));
-    if (!tRes.ok)
-        return err(tRes.error);
-    const sRes = parseNaming(flagValHelper(args, '--naming-case-schema'));
-    if (!sRes.ok)
-        return err(sRes.error);
-    return ok({
-        input: io.value.input,
-        output: io.value.output,
-        exportType: hasFlagHelper(args, '--export-type') ? true : undefined,
-        exportSchema: hasFlagHelper(args, '--export-schema') ? true : undefined,
-        typeCase: tRes.value,
-        schemaCase: sRes.value,
-        template: hasFlagHelper(args, '--template'),
-        test: hasFlagHelper(args, '--test'),
-        basePath: flagValHelper(args, '--base-path'),
-    });
+export function parseCliArgs(args, config) {
+    return andThen(parseIO(args, config), (io) => andThen(parseNaming(flagVal(args, '--naming-case-type')), (typeCase) => andThen(parseNaming(flagVal(args, '--naming-case-schema')), (schemaCase) => ok({
+        input: io.input,
+        output: io.output,
+        exportType: hasFlag(args, '--export-type') ? true : undefined,
+        exportSchema: hasFlag(args, '--export-schema') ? true : undefined,
+        typeCase,
+        schemaCase,
+        template: hasFlag(args, '--template'),
+        test: hasFlag(args, '--test'),
+        basePath: flagVal(args, '--base-path'),
+    }))));
 }

package/dist/cli/validator/parse-help.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Checks if help was requested from the CLI arguments.
+ * @param args - The CLI arguments
+ * @returns boolean
+ */
+export declare function parseHelp(args: readonly string[]): boolean;

package/dist/cli/validator/parse-help.js

@@ -0,0 +1,8 @@
+/**
+ * Checks if help was requested from the CLI arguments.
+ * @param args - The CLI arguments
+ * @returns boolean
+ */
+export function parseHelp(args) {
+    return args.length === 1 && (args[0] === '--help' || args[0] === '-h');
+}

package/dist/cli/validator/parse-io.d.ts

@@ -0,0 +1,13 @@
+import type { Result } from '../../result/index.js';
+/**
+ * @param args - The CLI arguments
+ * @param config - The configuration object containing input and output file paths
+ * @returns A Result containing the input and output file paths or an error message
+ */
+export declare function parseIO(args: readonly string[], config: {
+    input?: `${string}.yaml` | `${string}.json`;
+    output?: `${string}.ts`;
+}): Result<{
+    input: `${string}.yaml` | `${string}.json`;
+    output: `${string}.ts`;
+}, string>;

package/dist/cli/validator/parse-io.js

@@ -0,0 +1,20 @@
+import { ok, err } from '../../result/index.js';
+import { isTs, isYamlOrJson } from './index.js';
+/**
+ * @param args - The CLI arguments
+ * @param config - The configuration object containing input and output file paths
+ * @returns A Result containing the input and output file paths or an error message
+ */
+export function parseIO(args, config) {
+    const cliInput = args[0];
+    const oIdx = args.indexOf('-o');
+    const cliOutput = oIdx !== -1 ? args[oIdx + 1] : undefined;
+    const input = cliInput ?? config.input;
+    const output = cliOutput ?? config.output;
+    if (output) {
+        if (isYamlOrJson(input) && isTs(output)) {
+            return ok({ input, output });
+        }
+    }
+    return err('Usage: hono-takibi <input.yaml|.json> -o <output.ts>');
+}

package/dist/cli/validator/parse-naming.d.ts

@@ -1,8 +1,7 @@
-import type { Result } from '../types/index.js';
-import type { Naming } from '../types/index.js';
+import type { Result } from '../../result/index.js';
 /**
  * Parses the naming case from a raw string.
- * @param raw - The raw naming case string.
+ * @param str - The raw naming case string.
  * @returns A Result containing the parsed Naming or an error message.
  */
-export declare function parseNaming(raw: string | undefined): Result<Naming | undefined>;
+export declare function parseNaming(str: string | undefined): Result<'PascalCase' | 'camelCase' | undefined, string>;

package/dist/cli/validator/parse-naming.js

@@ -1,13 +1,13 @@
-import { ok, err } from '../types/index.js';
+import { ok, err } from '../../result/index.js';
 /**
  * Parses the naming case from a raw string.
- * @param raw - The raw naming case string.
+ * @param str - The raw naming case string.
  * @returns A Result containing the parsed Naming or an error message.
  */
-export function parseNaming(raw) {
-    if (raw === 'PascalCase' || raw === 'camelCase')
-        return ok(raw);
-    if (raw === undefined)
+export function parseNaming(str) {
+    if (str === 'PascalCase' || str === 'camelCase')
+        return ok(str);
+    if (str === undefined)
         return ok(undefined);
-    return err(`--naming-case must be PascalCase or camelCase (got ${raw})`);
+    return err(`--naming-case must be PascalCase or camelCase (got ${str})`);
 }

package/dist/config/index.d.ts

@@ -1,3 +1,4 @@
+import type { Result } from '../result/types.js';
 export type Config = {
     schema: {
         name: 'PascalCase' | 'camelCase';
@@ -7,12 +8,21 @@ export type Config = {
         name: 'PascalCase' | 'camelCase';
         export: boolean;
     };
-    input?: string;
-    output?: string;
+    input?: `${string}.yaml` | `${string}.json`;
+    output?: `${string}.ts`;
+};
+export declare const DEFAULT_CONFIG: {
+    readonly schema: {
+        readonly name: "PascalCase";
+        readonly export: false;
+    };
+    readonly type: {
+        readonly name: "PascalCase";
+        readonly export: false;
+    };
 };
-export declare const DEFAULT_CONFIG: Config;
 /**
  * Loads the configuration from the `hono-takibi.json` file or returns the default configuration.
- * @returns { Config } The configuration object.
+ * @returns { Result<Config, string> } - A Result containing the configuration or an error message.
  */
-export declare function getConfig(): Config;
+export declare function getConfig(): Result<Config, string>;

package/dist/config/index.js

@@ -1,4 +1,6 @@
 import fs from 'node:fs';
+import { ok } from '../result/ok.js';
+import { err } from '../result/err.js';
 export const DEFAULT_CONFIG = {
     schema: {
         name: 'PascalCase',
@@ -11,11 +13,16 @@ export const DEFAULT_CONFIG = {
 };
 /**
  * Loads the configuration from the `hono-takibi.json` file or returns the default configuration.
- * @returns { Config } The configuration object.
+ * @returns { Result<Config, string> } - A Result containing the configuration or an error message.
  */
 export function getConfig() {
-    const config = fs.existsSync('hono-takibi.json')
-        ? { ...DEFAULT_CONFIG, ...JSON.parse(fs.readFileSync('hono-takibi.json', 'utf-8')) }
-        : DEFAULT_CONFIG;
-    return config;
+    try {
+        const config = fs.existsSync('hono-takibi.json')
+            ? { ...DEFAULT_CONFIG, ...JSON.parse(fs.readFileSync('hono-takibi.json', 'utf-8')) }
+            : DEFAULT_CONFIG;
+        return ok(config);
+    }
+    catch (e) {
+        return err(e instanceof Error ? e.message : String(e));
+    }
 }

package/dist/core/helper/{get-camel-case-schema-name-helper.d.ts → get-camel-case-schema-name.d.ts}

@@ -3,4 +3,4 @@
  * @param { string } schemaName - The original schema name.
  * @returns { string } The camelCase schema name.
  */
-export declare function getCamelCaseSchemaNameHelper(schemaName: string): string;
+export declare function getCamelCaseSchemaName(schemaName: string): string;

package/dist/core/helper/{get-camel-case-schema-name-helper.js → get-camel-case-schema-name.js}

@@ -4,7 +4,7 @@ import { decapitalize } from '../text/index.js';
  * @param { string } schemaName - The original schema name.
  * @returns { string } The camelCase schema name.
  */
-export function getCamelCaseSchemaNameHelper(schemaName) {
+export function getCamelCaseSchemaName(schemaName) {
     const decapitalizedSchemaName = decapitalize(schemaName);
     return `${decapitalizedSchemaName}Schema`;
 }

package/dist/core/helper/{get-pascal-case-schema-name-helper.d.ts → get-pascal-case-schema-name.d.ts}

@@ -3,4 +3,4 @@
  * @param { string } schemaName - The original schema name.
  * @returns { string } The PascalCase schema name.
  */
-export declare function getPascalCaseSchemaNameHelper(schemaName: string): string;
+export declare function getPascalCaseSchemaName(schemaName: string): string;

package/dist/core/helper/{get-pascal-case-schema-name-helper.js → get-pascal-case-schema-name.js}

@@ -4,7 +4,7 @@ import { capitalize } from '../text/index.js';
  * @param { string } schemaName - The original schema name.
  * @returns { string } The PascalCase schema name.
  */
-export function getPascalCaseSchemaNameHelper(schemaName) {
+export function getPascalCaseSchemaName(schemaName) {
     const capitalizedSchemaName = capitalize(schemaName);
     return `${capitalizedSchemaName}Schema`;
 }

package/dist/core/helper/get-to-safe-identifier.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Converts a string to a safe TypeScript object key.
+ * - Returns as-is if it's a valid identifier
+ * - Otherwise wraps it in double quotes (via JSON.stringify)
+ */
+export declare function getToSafeIdentifier(str: string): string;

package/dist/core/helper/get-to-safe-identifier.js

@@ -0,0 +1,8 @@
+/**
+ * Converts a string to a safe TypeScript object key.
+ * - Returns as-is if it's a valid identifier
+ * - Otherwise wraps it in double quotes (via JSON.stringify)
+ */
+export function getToSafeIdentifier(str) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(str) ? str : JSON.stringify(str);
+}

package/dist/core/helper/{get-variable-name-helper.d.ts → get-variable-name.d.ts}

@@ -5,4 +5,4 @@ import type { Config } from '../../config/index.js';
  * @param { Config } config - The config of the schema.
  * @returns { string } The variable name.
  */
-export declare function getVariableNameHelper(name: string, config: Config): string;
+export declare function getVariableName(name: string, config: Config): string;

package/dist/core/helper/{get-variable-name-helper.js → get-variable-name.js}

@@ -5,6 +5,6 @@ import { capitalize, decapitalize } from '../text/index.js';
  * @param { Config } config - The config of the schema.
  * @returns { string } The variable name.
  */
-export function getVariableNameHelper(name, config) {
+export function getVariableName(name, config) {
     return config.type.name === 'camelCase' ? decapitalize(name) : capitalize(name);
 }

package/dist/core/helper/{get-variable-schema-name-helper.d.ts → get-variable-schema-name.d.ts}

@@ -5,4 +5,4 @@ import type { Config } from '../../config/index.js';
  * @param { Config } config - The config of the schema.
  * @returns { string } The variable schema name.
  */
-export declare function getVariableSchemaNameHelper(name: string, config: Config): string;
+export declare function getVariableSchemaName(name: string, config: Config): string;

package/dist/core/helper/{get-variable-schema-name-helper.js → get-variable-schema-name.js}

@@ -1,12 +1,12 @@
-import { getCamelCaseSchemaNameHelper, getPascalCaseSchemaNameHelper } from './index.js';
+import { getCamelCaseSchemaName, getPascalCaseSchemaName } from './index.js';
 /**
  * Generates a variable schema name from a given name and config.
  * @param { string } name - The name of the schema.
  * @param { Config } config - The config of the schema.
  * @returns { string } The variable schema name.
  */
-export function getVariableSchemaNameHelper(name, config) {
+export function getVariableSchemaName(name, config) {
     return config.schema.name === 'camelCase'
-        ? getCamelCaseSchemaNameHelper(name)
-        : getPascalCaseSchemaNameHelper(name);
+        ? getCamelCaseSchemaName(name)
+        : getPascalCaseSchemaName(name);
 }