@omnifyjp/ts 5.8.33 → 5.8.35

package/dist/cli.js

@@ -107,6 +107,7 @@ function resolveFromConfig(configPath) {
         tsOutput,
         tsPlatform: tsConfig?.platform,
         tsAuth: tsConfig?.auth,
+        tsEnumStyle: tsConfig?.enumStyle,
         laravelEnabled,
         laravelOverrides,
     };
@@ -127,6 +128,7 @@ program
     let tsOutput;
     let tsPlatform;
     let tsAuth;
+    let tsEnumStyle;
     let laravelEnabled = false;
     let laravelOverrides;
     let configDir = process.cwd();
@@ -151,6 +153,7 @@ program
         tsOutput = opts.output ? resolve(opts.output) : resolved.tsOutput;
         tsPlatform = resolved.tsPlatform;
         tsAuth = resolved.tsAuth;
+        tsEnumStyle = resolved.tsEnumStyle;
         laravelEnabled = resolved.laravelEnabled;
         laravelOverrides = resolved.laravelOverrides;
     }
@@ -178,6 +181,7 @@ program
         const files = generateTypeScript(input, {
             platform: tsPlatform,
             auth: tsAuth,
+            enumStyle: tsEnumStyle,
         });
         mkdirSync(join(tsOutput, 'base'), { recursive: true });
         mkdirSync(join(tsOutput, 'enum'), { recursive: true });

package/dist/enum-generator.d.ts

@@ -15,8 +15,23 @@ export declare function schemaToEnum(schema: SchemaDefinition, options: Generato
 export declare function generateEnums(schemas: Record<string, SchemaDefinition>, options: GeneratorOptions): TSEnum[];
 /** Generate enums from plugin enums (customTypes.enums in schemas.json). */
 export declare function generatePluginEnums(pluginEnums: Record<string, string[]>, _options: GeneratorOptions): TSEnum[];
-/** Format a TypeScript enum with helpers (Values array, type guard, label getter). */
-export declare function formatEnum(enumDef: TSEnum): string;
+/** Format a TypeScript enum with helpers (Values array, type guard, label getter).
+ *
+ * Two emission shapes (issue #103 Issue 1):
+ *
+ *   - `'enum'` (DEFAULT): native `export enum X { ... }` — backwards-
+ *     compatible with every project that depended on TS enum semantics
+ *     (declaration merging via namespace, etc.) before v5.8.34.
+ *
+ *   - `'const'`: `export const X = {...} as const; export type X = ...` —
+ *     compiles under TS 5.5+ `erasableSyntaxOnly` (Vite 7 default).
+ *     Call-site ergonomics identical to enum: `X.User === 'user'` works,
+ *     string union narrowing works, all helper signatures unchanged.
+ *
+ * Pass `style` to pick. Default preserves the pre-v5.8.34 behavior so an
+ * upgrade without config change doesn't break consumer code.
+ */
+export declare function formatEnum(enumDef: TSEnum, style?: 'enum' | 'const'): string;
 /** Format a TypeScript type alias with helpers. */
 export declare function formatTypeAlias(alias: TSTypeAlias): string;
 /** Result of extracting inline enums. */

package/dist/enum-generator.js

@@ -97,16 +97,45 @@ function lowerFirst(str) {
 function escapeString(str) {
     return str.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
 }
-/** Format a TypeScript enum with helpers (Values array, type guard, label getter). */
-export function formatEnum(enumDef) {
+/** Format a TypeScript enum with helpers (Values array, type guard, label getter).
+ *
+ * Two emission shapes (issue #103 Issue 1):
+ *
+ *   - `'enum'` (DEFAULT): native `export enum X { ... }` — backwards-
+ *     compatible with every project that depended on TS enum semantics
+ *     (declaration merging via namespace, etc.) before v5.8.34.
+ *
+ *   - `'const'`: `export const X = {...} as const; export type X = ...` —
+ *     compiles under TS 5.5+ `erasableSyntaxOnly` (Vite 7 default).
+ *     Call-site ergonomics identical to enum: `X.User === 'user'` works,
+ *     string union narrowing works, all helper signatures unchanged.
+ *
+ * Pass `style` to pick. Default preserves the pre-v5.8.34 behavior so an
+ * upgrade without config change doesn't break consumer code.
+ */
+export function formatEnum(enumDef, style = 'enum') {
     const { name, values, comment } = enumDef;
     const parts = [];
     if (comment) {
         parts.push(`/**\n * ${comment}\n */\n`);
     }
-    // Enum definition
-    const enumValues = values.map(v => `  ${v.name} = '${v.value}',`).join('\n');
-    parts.push(`export enum ${name} {\n${enumValues}\n}\n\n`);
+    if (style === 'const') {
+        // Const object — works under erasableSyntaxOnly. Identical access at
+        // call sites: `X.User === 'user'` (literal string equality).
+        const enumValues = values.map(v => `  ${v.name}: '${v.value}',`).join('\n');
+        parts.push(`export const ${name} = {\n${enumValues}\n} as const;\n\n`);
+        // Type alias — string union derived from the const object's values.
+        // The `keyof typeof` extraction is the canonical TS pattern for this.
+        parts.push(`export type ${name} = typeof ${name}[keyof typeof ${name}];\n\n`);
+    }
+    else {
+        // Native `enum` — pre-v5.8.34 default. Some downstream projects
+        // depend on declaration-merging or other TS-enum-specific semantics
+        // that the const-object pattern can't replicate, so we keep this
+        // available as the safe upgrade path.
+        const enumValues = values.map(v => `  ${v.name} = '${v.value}',`).join('\n');
+        parts.push(`export enum ${name} {\n${enumValues}\n}\n\n`);
+    }
     // Values array
     parts.push(`/** All ${name} values */\n`);
     parts.push(`export const ${name}Values = Object.values(${name}) as ${name}[];\n\n`);

package/dist/generator.d.ts

@@ -18,6 +18,8 @@ import type { SchemasJson, TypeScriptFile } from './types.js';
 export interface GenerateExtraConfig {
     platform?: 'web' | 'expo';
     auth?: 'cookie' | 'secureStore';
+    /** Enum emission style — see GeneratorOptions.enumStyle. Issue #103. */
+    enumStyle?: 'enum' | 'const';
 }
 /**
  * Generate all TypeScript files from schemas.json input.

package/dist/generator.js

@@ -42,6 +42,7 @@ function buildOptions(input, extra) {
         customTypes: input.customTypes,
         platform: extra?.platform,
         auth: extra?.auth,
+        enumStyle: extra?.enumStyle,
     };
 }
 /** Generate a base interface file for a schema. */
@@ -106,10 +107,15 @@ function generateBaseInterfaceFile(schemaName, schemas, options) {
     // would be empty noise.
     const formShape = buildFormShape(schema, schemas, options);
     if (formShape.fields.length > 0) {
-        // The builders depend on `Locale` (from common.ts) and the shared
-        // `buildI18nPayload` / `emptyLocaleMap` helpers (from payload-helpers.ts).
-        // Inject the imports near the top of the file.
-        insertPayloadImports(parts);
+        // The builders only reference `Locale` / `buildI18nPayload` /
+        // `emptyLocaleMap` for translatable fields. When the schema has no
+        // translatable field, those imports would be unused → trip TS6133
+        // (declared but never read) under noUnusedLocals. Pilot #103 Issue 2
+        // — emit imports conditionally on actual i18n usage.
+        const hasTranslatableField = formShape.fields.some(f => f.translatable);
+        if (hasTranslatableField) {
+            insertPayloadImports(parts);
+        }
         parts.push(formatPayloadBuilderSection(formShape, options.defaultLocale));
     }
     return {
@@ -139,9 +145,9 @@ function insertPayloadImports(parts) {
     parts.splice(1, 0, importBlock);
 }
 /** Generate an enum file. */
-function generateEnumFile(enumDef, isPlugin) {
+function generateEnumFile(enumDef, isPlugin, options) {
     const parts = [generateBaseHeader()];
-    parts.push(formatEnum(enumDef));
+    parts.push(formatEnum(enumDef, options.enumStyle));
     parts.push('\n');
     return {
         filePath: `${enumDef.name}.ts`,
@@ -451,12 +457,12 @@ export function generateTypeScript(input, extra) {
     // Schema enums (e.g., PostStatus)
     const schemaEnums = generateEnums(schemas, options);
     for (const enumDef of schemaEnums) {
-        files.push(generateEnumFile(enumDef, false));
+        files.push(generateEnumFile(enumDef, false, options));
     }
     // Plugin enums (e.g., Prefecture, BankAccountType from customTypes.enums)
     const pluginEnums = generatePluginEnums(input.customTypes.enums, options);
     for (const enumDef of pluginEnums) {
-        files.push(generateEnumFile(enumDef, true));
+        files.push(generateEnumFile(enumDef, true, options));
     }
     // Inline enums from properties (type aliases or full enums)
     const inlineEnums = extractInlineEnums(schemas, options);
@@ -464,7 +470,7 @@ export function generateTypeScript(input, extra) {
     for (const item of inlineEnums) {
         if (item.enum) {
             schemaEnums.push(item.enum);
-            files.push(generateEnumFile(item.enum, false));
+            files.push(generateEnumFile(item.enum, false, options));
         }
         else if (item.typeAlias) {
             inlineTypeAliases.push(item.typeAlias);

package/dist/types.d.ts

@@ -448,4 +448,25 @@ export interface GeneratorOptions {
     readonly platform?: 'web' | 'expo';
     /** Auth strategy: 'cookie' (default) or 'secureStore' (Expo). Issue #63. */
     readonly auth?: 'cookie' | 'secureStore';
+    /**
+     * Enum emission style. Issue #103 Issue 1.
+     *
+     * - `'enum'` (default): emit `export enum X { ... }` — TypeScript native
+     *   syntax. Compatible with projects predating TS 5.5 / projects that
+     *   declaration-merge enums via namespace. INCOMPATIBLE with the
+     *   `erasableSyntaxOnly` strict-mode option (TS 5.5+ default in Vite 7
+     *   starters), which rejects enums because they emit runtime code that
+     *   type-only-stripping tools (esbuild/deno/bun) can't erase.
+     *
+     * - `'const'`: emit `export const X = {...} as const; export type X = ...`
+     *   — works under all strict modes. Identical call-site ergonomics
+     *   (`X.User === 'user'`, type narrowing, helper functions). Pilot
+     *   downstream uses this when their tsconfig enables erasableSyntaxOnly.
+     *
+     * Default `'enum'` preserves backwards compatibility for projects
+     * upgrading omnify without changing their omnify.yaml — set
+     * `enumStyle: 'const'` explicitly to opt into the strict-mode-friendly
+     * output.
+     */
+    readonly enumStyle?: 'enum' | 'const';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/ts",
-  "version": "5.8.33",
+  "version": "5.8.35",
   "description": "TypeScript model type generator from Omnify schemas.json",
   "type": "module",
   "main": "dist/index.js",