@omnifyjp/omnify 5.8.32 → 5.8.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/omnify",
-  "version": "5.8.32",
+  "version": "5.8.34",
   "description": "Schema-driven code generation for Laravel, TypeScript, and SQL",
   "license": "MIT",
   "repository": {
@@ -36,10 +36,10 @@
     "zod": "^3.24.0"
   },
   "optionalDependencies": {
-    "@omnifyjp/omnify-darwin-arm64": "5.8.32",
-    "@omnifyjp/omnify-darwin-x64": "5.8.32",
-    "@omnifyjp/omnify-linux-x64": "5.8.32",
-    "@omnifyjp/omnify-linux-arm64": "5.8.32",
-    "@omnifyjp/omnify-win32-x64": "5.8.32"
+    "@omnifyjp/omnify-darwin-arm64": "5.8.34",
+    "@omnifyjp/omnify-darwin-x64": "5.8.34",
+    "@omnifyjp/omnify-linux-x64": "5.8.34",
+    "@omnifyjp/omnify-linux-arm64": "5.8.34",
+    "@omnifyjp/omnify-win32-x64": "5.8.34"
   }
 }

package/ts-dist/enum-generator.d.ts

@@ -15,7 +15,18 @@ 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). */
+/** Format a TypeScript enum with helpers (Values array, type guard, label getter).
+ *
+ * Emits the `as const` object pattern instead of `export enum X { ... }`.
+ * Reasoning: TS 5.5+ ships with `erasableSyntaxOnly` enabled by default in
+ * Vite 7 starters and recommended by the TS team for new projects, which
+ * disallows enums (they emit runtime code that type-only-stripping tools
+ * like esbuild + deno + bun can't erase). The const-object pattern
+ * preserves identical call-site ergonomics — `X.User` still resolves to
+ * the string value, the union type still narrows correctly, label /
+ * value-array helpers all work — but compiles under every strict-mode
+ * preset. Pilot #103 Issue 1.
+ */
 export declare function formatEnum(enumDef: TSEnum): string;
 /** Format a TypeScript type alias with helpers. */
 export declare function formatTypeAlias(alias: TSTypeAlias): string;

package/ts-dist/enum-generator.js

@@ -97,16 +97,33 @@ function lowerFirst(str) {
 function escapeString(str) {
     return str.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
 }
-/** Format a TypeScript enum with helpers (Values array, type guard, label getter). */
+/** Format a TypeScript enum with helpers (Values array, type guard, label getter).
+ *
+ * Emits the `as const` object pattern instead of `export enum X { ... }`.
+ * Reasoning: TS 5.5+ ships with `erasableSyntaxOnly` enabled by default in
+ * Vite 7 starters and recommended by the TS team for new projects, which
+ * disallows enums (they emit runtime code that type-only-stripping tools
+ * like esbuild + deno + bun can't erase). The const-object pattern
+ * preserves identical call-site ergonomics — `X.User` still resolves to
+ * the string value, the union type still narrows correctly, label /
+ * value-array helpers all work — but compiles under every strict-mode
+ * preset. Pilot #103 Issue 1.
+ */
 export function formatEnum(enumDef) {
     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`);
+    // 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. A
+    // function parameter typed `${name}` accepts `X.User` AND the literal
+    // 'user' (same shape as enums had). The `keyof typeof` extraction is
+    // the canonical TS pattern for this.
+    parts.push(`export type ${name} = typeof ${name}[keyof typeof ${name}];\n\n`);
     // Values array
     parts.push(`/** All ${name} values */\n`);
     parts.push(`export const ${name}Values = Object.values(${name}) as ${name}[];\n\n`);

package/ts-dist/generator.js

@@ -106,10 +106,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 {