@famgia/omnify-laravel 0.0.17 → 0.0.19

package/README.md

@@ -90,11 +90,13 @@ const types = generateTypeScript(schemas, {
 
 - Laravel migration generation
 - TypeScript interface generation
+- Eloquent model generation with localization support
 - Support for all Laravel column types
 - Relationship handling (belongsTo, hasMany, etc.)
 - Index and constraint generation
 - Enum type support
 - Plugin system with DAG-based generator ordering
+- Multi-language displayName support (i18n)
 
 ## Generated Output
 
@@ -135,6 +137,134 @@ export interface User {
 }
 ```
 
+### Eloquent Models with Localized Display Names
+
+The generator creates a clean model structure with separated locale data:
+
+```
+app/Models/OmnifyBase/
+├── Traits/
+│   └── HasLocalizedDisplayName.php  # Reusable trait
+├── Locales/
+│   ├── UserLocales.php              # User locale data
+│   ├── PostLocales.php              # Post locale data
+│   └── ...
+├── UserBaseModel.php                # Clean base model
+├── PostBaseModel.php
+└── ...
+```
+
+#### Schema Definition with i18n
+
+Define multi-language displayNames in your YAML schema:
+
+```yaml
+# schemas/auth/User.yaml
+name: User
+displayName:
+  ja: ユーザー
+  en: User
+  vi: Người dùng
+
+properties:
+  name:
+    type: String
+    displayName:
+      ja: 氏名
+      en: Full Name
+      vi: Họ tên
+
+  email:
+    type: String
+    unique: true
+    displayName:
+      ja: メールアドレス
+      en: Email Address
+      vi: Địa chỉ email
+```
+
+#### Generated Locales Class
+
+```php
+// app/Models/OmnifyBase/Locales/UserLocales.php
+class UserLocales
+{
+    public const DISPLAY_NAMES = [
+        'ja' => 'ユーザー',
+        'en' => 'User',
+        'vi' => 'Người dùng',
+    ];
+
+    public const PROPERTY_DISPLAY_NAMES = [
+        'name' => [
+            'ja' => '氏名',
+            'en' => 'Full Name',
+            'vi' => 'Họ tên',
+        ],
+        // ...
+    ];
+}
+```
+
+#### Generated Base Model
+
+```php
+// app/Models/OmnifyBase/UserBaseModel.php
+use App\Models\OmnifyBase\Traits\HasLocalizedDisplayName;
+use App\Models\OmnifyBase\Locales\UserLocales;
+
+class UserBaseModel extends Authenticatable
+{
+    use HasLocalizedDisplayName;
+
+    protected static array $localizedDisplayNames = UserLocales::DISPLAY_NAMES;
+    protected static array $localizedPropertyDisplayNames = UserLocales::PROPERTY_DISPLAY_NAMES;
+
+    // ... rest of model
+}
+```
+
+#### Using Localized Display Names in PHP
+
+```php
+// Get model display name (uses Laravel's app()->getLocale())
+User::displayName();           // "ユーザー" (if locale is 'ja')
+User::displayName('en');       // "User"
+User::displayName('vi');       // "Người dùng"
+
+// Get property display name
+User::propertyDisplayName('name');        // "氏名" (if locale is 'ja')
+User::propertyDisplayName('name', 'en');  // "Full Name"
+
+// Get all display names
+User::allDisplayNames();  // ['ja' => 'ユーザー', 'en' => 'User', 'vi' => 'Người dùng']
+
+// Get all property names for current locale
+User::allPropertyDisplayNamesForLocale();  // ['name' => '氏名', 'email' => 'メールアドレス', ...]
+```
+
+#### Locale Configuration
+
+Configure locales in `omnify.config.ts`:
+
+```typescript
+import { defineConfig } from '@famgia/omnify';
+import laravel from '@famgia/omnify-laravel/plugin';
+
+export default defineConfig({
+  schemasDir: './schemas',
+
+  // Locale configuration
+  locale: {
+    locales: ['ja', 'en', 'vi'],
+    defaultLocale: 'ja',
+    fallbackLocale: 'en',
+  },
+
+  plugins: [laravel()],
+});
+```
+
 ## Creating Custom Plugins
 
 You can create your own generator plugins following this pattern:

package/dist/{chunk-52JAFQBQ.js → chunk-ILSNN7UV.js}

@@ -1,5 +1,5 @@
 // src/plugin.ts
-import { readFileSync, existsSync } from "fs";
+import { readFileSync, existsSync, readdirSync } from "fs";
 import { join } from "path";
 
 // src/migration/schema-builder.ts
@@ -14,6 +14,7 @@ var TYPE_METHOD_MAP = {
   LongText: "longText",
   Date: "date",
   Time: "time",
+  DateTime: "dateTime",
   Timestamp: "timestamp",
   Json: "json",
   Email: "string",
@@ -86,6 +87,10 @@ function propertyToColumnMethod(propertyName, property) {
   if (baseProp.unsigned && (method === "integer" || method === "bigInteger")) {
     modifiers.push({ method: "unsigned" });
   }
+  const displayName = property.displayName;
+  if (displayName) {
+    modifiers.push({ method: "comment", args: [displayName] });
+  }
   return {
     name: columnName,
     method,
@@ -220,6 +225,9 @@ function generateForeignKey(propertyName, property, allSchemas) {
   if (assocProp.default !== void 0 && assocProp.default !== null) {
     modifiers.push({ method: "default", args: [assocProp.default] });
   }
+  if (assocProp.displayName) {
+    modifiers.push({ method: "comment", args: [assocProp.displayName] });
+  }
   const column = {
     name: columnName,
     method,
@@ -239,7 +247,65 @@ function generateForeignKey(propertyName, property, allSchemas) {
   };
   return { column, foreignKey, index };
 }
-function schemaToBlueprint(schema, allSchemas) {
+function expandCompoundType(propName, property, customTypes) {
+  const typeDef = customTypes.get(property.type);
+  if (!typeDef || !typeDef.compound || !typeDef.expand) {
+    return null;
+  }
+  const expanded = [];
+  const baseProp = property;
+  for (const field of typeDef.expand) {
+    const suffixSnake = toColumnName(field.suffix);
+    const columnName = `${propName}_${suffixSnake}`;
+    const expandedProp = {
+      type: "String"
+      // Default type, will be overridden by sql definition
+    };
+    if (field.sql) {
+      const sqlType = field.sql.sqlType.toUpperCase();
+      if (sqlType === "VARCHAR" || sqlType === "CHAR" || sqlType === "STRING") {
+        expandedProp.type = "String";
+        if (field.sql.length) {
+          expandedProp.length = field.sql.length;
+        }
+      } else if (sqlType === "INT" || sqlType === "INTEGER") {
+        expandedProp.type = "Int";
+      } else if (sqlType === "BIGINT") {
+        expandedProp.type = "BigInt";
+      } else if (sqlType === "TEXT") {
+        expandedProp.type = "Text";
+      } else if (sqlType === "BOOLEAN" || sqlType === "BOOL") {
+        expandedProp.type = "Boolean";
+      } else if (sqlType === "DECIMAL") {
+        expandedProp.type = "Decimal";
+        if (field.sql.precision) expandedProp.precision = field.sql.precision;
+        if (field.sql.scale) expandedProp.scale = field.sql.scale;
+      } else if (sqlType === "DATE") {
+        expandedProp.type = "Date";
+      } else if (sqlType === "TIMESTAMP" || sqlType === "DATETIME") {
+        expandedProp.type = "Timestamp";
+      }
+      if (field.sql.nullable !== void 0) {
+        expandedProp.nullable = field.sql.nullable;
+      } else if (baseProp.nullable !== void 0) {
+        expandedProp.nullable = baseProp.nullable;
+      }
+      if (field.sql.default !== void 0) {
+        expandedProp.default = field.sql.default;
+      }
+    }
+    if (baseProp.displayName) {
+      expandedProp.displayName = `${baseProp.displayName} (${field.suffix})`;
+    }
+    expanded.push({
+      name: columnName,
+      property: expandedProp
+    });
+  }
+  return expanded;
+}
+function schemaToBlueprint(schema, allSchemas, options = {}) {
+  const { customTypes = /* @__PURE__ */ new Map() } = options;
   const tableName = toTableName(schema.name);
   const columns = [];
   const foreignKeys = [];
@@ -250,6 +316,16 @@ function schemaToBlueprint(schema, allSchemas) {
   }
   if (schema.properties) {
     for (const [propName, property] of Object.entries(schema.properties)) {
+      const expandedProps = expandCompoundType(propName, property, customTypes);
+      if (expandedProps) {
+        for (const { name: expandedName, property: expandedProp } of expandedProps) {
+          const columnMethod2 = propertyToColumnMethod(expandedName, expandedProp);
+          if (columnMethod2) {
+            columns.push(columnMethod2);
+          }
+        }
+        continue;
+      }
       const columnMethod = propertyToColumnMethod(propName, property);
       if (columnMethod) {
         columns.push(columnMethod);
@@ -696,7 +772,9 @@ function generateMigrations(schemas, options = {}) {
     const timestamp = options.timestamp ?? generateTimestamp();
     const offsetTimestamp = incrementTimestamp(timestamp, timestampOffset);
     timestampOffset++;
-    const blueprint = schemaToBlueprint(schema, schemas);
+    const blueprint = schemaToBlueprint(schema, schemas, {
+      customTypes: options.customTypes
+    });
     const migration = generateCreateMigration(blueprint, {
       ...options,
       timestamp: offsetTimestamp
@@ -774,6 +852,7 @@ var TYPE_METHOD_MAP2 = {
   LongText: "longText",
   Date: "date",
   Time: "time",
+  DateTime: "dateTime",
   Timestamp: "timestamp",
   Json: "json",
   Email: "string",
@@ -1043,6 +1122,9 @@ function generateMigrationsFromChanges(changes, options = {}) {
   return migrations;
 }
 
+// src/model/generator.ts
+import { isLocaleMap } from "@famgia/omnify-types";
+
 // src/utils.ts
 function toSnakeCase(str) {
   return str.replace(/([A-Z])/g, "_$1").replace(/^_/, "").toLowerCase();
@@ -1072,6 +1154,45 @@ var DEFAULT_OPTIONS = {
   baseModelPath: "app/Models/OmnifyBase",
   modelPath: "app/Models"
 };
+function generateLocalizedDisplayNames(displayName, indent = "        ") {
+  if (displayName === void 0) {
+    return "";
+  }
+  if (typeof displayName === "string") {
+    return `${indent}'en' => '${escapePhpString(displayName)}',`;
+  }
+  if (isLocaleMap(displayName)) {
+    const entries = Object.entries(displayName).map(([locale, value]) => `${indent}'${locale}' => '${escapePhpString(value)}',`).join("\n");
+    return entries;
+  }
+  return "";
+}
+function generatePropertyLocalizedDisplayNames(schema, indent = "        ") {
+  const properties = schema.properties ?? {};
+  const entries = [];
+  for (const [propName, propDef] of Object.entries(properties)) {
+    const snakeName = toSnakeCase(propName);
+    const displayName = propDef.displayName;
+    if (displayName === void 0) {
+      continue;
+    }
+    const innerIndent = indent + "    ";
+    if (typeof displayName === "string") {
+      entries.push(`${indent}'${snakeName}' => [
+${innerIndent}'en' => '${escapePhpString(displayName)}',
+${indent}],`);
+    } else if (isLocaleMap(displayName)) {
+      const localeEntries = Object.entries(displayName).map(([locale, value]) => `${innerIndent}'${locale}' => '${escapePhpString(value)}',`).join("\n");
+      entries.push(`${indent}'${snakeName}' => [
+${localeEntries}
+${indent}],`);
+    }
+  }
+  return entries.join("\n");
+}
+function escapePhpString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
 function resolveOptions(options) {
   return {
     baseModelNamespace: options?.baseModelNamespace ?? DEFAULT_OPTIONS.baseModelNamespace,
@@ -1454,11 +1575,14 @@ use Illuminate\\Database\\Eloquent\\Relations\\MorphOne;
 use Illuminate\\Database\\Eloquent\\Relations\\MorphMany;
 use Illuminate\\Database\\Eloquent\\Relations\\MorphToMany;
 use Illuminate\\Database\\Eloquent\\Collection as EloquentCollection;
+use {{BASE_MODEL_NAMESPACE}}\\Traits\\HasLocalizedDisplayName;
+use {{BASE_MODEL_NAMESPACE}}\\Locales\\{{CLASS_NAME}}Locales;
 {{IMPORTS}}
 
 {{DOC_COMMENT}}
 class {{CLASS_NAME}}BaseModel extends {{BASE_MODEL_CLASS}}
 {
+    use HasLocalizedDisplayName;
 {{TRAITS}}
     /**
      * The table associated with the model.
@@ -1477,6 +1601,20 @@ class {{CLASS_NAME}}BaseModel extends {{BASE_MODEL_CLASS}}
      */
     public $timestamps = {{TIMESTAMPS}};
 
+    /**
+     * Localized display names for this model.
+     *
+     * @var array<string, string>
+     */
+    protected static array $localizedDisplayNames = {{CLASS_NAME}}Locales::DISPLAY_NAMES;
+
+    /**
+     * Localized display names for properties.
+     *
+     * @var array<string, array<string, string>>
+     */
+    protected static array $localizedPropertyDisplayNames = {{CLASS_NAME}}Locales::PROPERTY_DISPLAY_NAMES;
+
     /**
      * The attributes that are mass assignable.
      */
@@ -1533,12 +1671,15 @@ use Illuminate\\Database\\Eloquent\\Relations\\MorphMany;
 use Illuminate\\Database\\Eloquent\\Relations\\MorphToMany;
 use Illuminate\\Database\\Eloquent\\Collection as EloquentCollection;
 use Illuminate\\Notifications\\Notifiable;
+use {{BASE_MODEL_NAMESPACE}}\\Traits\\HasLocalizedDisplayName;
+use {{BASE_MODEL_NAMESPACE}}\\Locales\\{{CLASS_NAME}}Locales;
 {{IMPORTS}}
 
 {{DOC_COMMENT}}
 class {{CLASS_NAME}}BaseModel extends Authenticatable
 {
     use Notifiable;
+    use HasLocalizedDisplayName;
 {{TRAITS}}
     /**
      * The table associated with the model.
@@ -1557,6 +1698,20 @@ class {{CLASS_NAME}}BaseModel extends Authenticatable
      */
     public $timestamps = {{TIMESTAMPS}};
 
+    /**
+     * Localized display names for this model.
+     *
+     * @var array<string, string>
+     */
+    protected static array $localizedDisplayNames = {{CLASS_NAME}}Locales::DISPLAY_NAMES;
+
+    /**
+     * Localized display names for properties.
+     *
+     * @var array<string, array<string, string>>
+     */
+    protected static array $localizedPropertyDisplayNames = {{CLASS_NAME}}Locales::PROPERTY_DISPLAY_NAMES;
+
     /**
      * The attributes that are mass assignable.
      */
@@ -1661,6 +1816,132 @@ class OmnifyServiceProvider extends ServiceProvider
         ]);
     }
 }
+`,
+    "has-localized-display-name": `<?php
+
+namespace {{BASE_MODEL_NAMESPACE}}\\Traits;
+
+/**
+ * Trait for localized display names.
+ * Uses Laravel's app()->getLocale() for locale resolution.
+ *
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by @famgia/omnify-laravel
+ */
+trait HasLocalizedDisplayName
+{
+    /**
+     * Get the localized display name for this model.
+     *
+     * @param string|null $locale Locale code (defaults to app locale)
+     * @return string
+     */
+    public static function displayName(?string $locale = null): string
+    {
+        $locale = $locale ?? app()->getLocale();
+        $displayNames = static::$localizedDisplayNames ?? [];
+
+        return $displayNames[$locale]
+            ?? $displayNames[config('app.fallback_locale', 'en')]
+            ?? $displayNames[array_key_first($displayNames) ?? 'en']
+            ?? class_basename(static::class);
+    }
+
+    /**
+     * Get all localized display names for this model.
+     *
+     * @return array<string, string>
+     */
+    public static function allDisplayNames(): array
+    {
+        return static::$localizedDisplayNames ?? [];
+    }
+
+    /**
+     * Get the localized display name for a property.
+     *
+     * @param string $property Property name
+     * @param string|null $locale Locale code (defaults to app locale)
+     * @return string
+     */
+    public static function propertyDisplayName(string $property, ?string $locale = null): string
+    {
+        $locale = $locale ?? app()->getLocale();
+        $displayNames = static::$localizedPropertyDisplayNames[$property] ?? [];
+
+        return $displayNames[$locale]
+            ?? $displayNames[config('app.fallback_locale', 'en')]
+            ?? $displayNames[array_key_first($displayNames) ?? 'en']
+            ?? $property;
+    }
+
+    /**
+     * Get all localized display names for a property.
+     *
+     * @param string $property Property name
+     * @return array<string, string>
+     */
+    public static function allPropertyDisplayNames(string $property): array
+    {
+        return static::$localizedPropertyDisplayNames[$property] ?? [];
+    }
+
+    /**
+     * Get all property display names for a given locale.
+     *
+     * @param string|null $locale Locale code (defaults to app locale)
+     * @return array<string, string>
+     */
+    public static function allPropertyDisplayNamesForLocale(?string $locale = null): array
+    {
+        $locale = $locale ?? app()->getLocale();
+        $result = [];
+
+        foreach (static::$localizedPropertyDisplayNames ?? [] as $property => $displayNames) {
+            $result[$property] = $displayNames[$locale]
+                ?? $displayNames[config('app.fallback_locale', 'en')]
+                ?? $displayNames[array_key_first($displayNames) ?? 'en']
+                ?? $property;
+        }
+
+        return $result;
+    }
+}
+`,
+    "locales": `<?php
+
+namespace {{BASE_MODEL_NAMESPACE}}\\Locales;
+
+/**
+ * Localized display names for {{CLASS_NAME}}.
+ *
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by @famgia/omnify-laravel
+ */
+class {{CLASS_NAME}}Locales
+{
+    /**
+     * Localized display names for the model.
+     *
+     * @var array<string, string>
+     */
+    public const DISPLAY_NAMES = [
+{{LOCALIZED_DISPLAY_NAMES}}
+    ];
+
+    /**
+     * Localized display names for properties.
+     *
+     * @var array<string, array<string, string>>
+     */
+    public const PROPERTY_DISPLAY_NAMES = [
+{{LOCALIZED_PROPERTY_DISPLAY_NAMES}}
+    ];
+}
 `
   };
   return stubs[stubName] ?? "";
@@ -1680,15 +1961,42 @@ function generateServiceProvider(schemas, options, stubContent) {
     schemaName: "__service_provider__"
   };
 }
+function generateLocalizedDisplayNameTrait(options, stubContent) {
+  const content = stubContent.replace(/\{\{BASE_MODEL_NAMESPACE\}\}/g, options.baseModelNamespace);
+  return {
+    path: `${options.baseModelPath}/Traits/HasLocalizedDisplayName.php`,
+    content,
+    type: "trait",
+    overwrite: true,
+    // Always overwrite trait
+    schemaName: "__trait__"
+  };
+}
+function generateLocalesClass(schema, options, stubContent) {
+  const className = toPascalCase(schema.name);
+  const localizedDisplayNames = generateLocalizedDisplayNames(schema.displayName);
+  const localizedPropertyDisplayNames = generatePropertyLocalizedDisplayNames(schema);
+  const content = stubContent.replace(/\{\{BASE_MODEL_NAMESPACE\}\}/g, options.baseModelNamespace).replace(/\{\{CLASS_NAME\}\}/g, className).replace(/\{\{LOCALIZED_DISPLAY_NAMES\}\}/g, localizedDisplayNames).replace(/\{\{LOCALIZED_PROPERTY_DISPLAY_NAMES\}\}/g, localizedPropertyDisplayNames);
+  return {
+    path: `${options.baseModelPath}/Locales/${className}Locales.php`,
+    content,
+    type: "locales",
+    overwrite: true,
+    // Always overwrite locales
+    schemaName: schema.name
+  };
+}
 function generateModels(schemas, options) {
   const resolved = resolveOptions(options);
   const models = [];
   models.push(generateBaseModel(schemas, resolved, getStubContent("base-model")));
+  models.push(generateLocalizedDisplayNameTrait(resolved, getStubContent("has-localized-display-name")));
   models.push(generateServiceProvider(schemas, resolved, getStubContent("service-provider")));
   for (const schema of Object.values(schemas)) {
     if (schema.kind === "enum") {
       continue;
     }
+    models.push(generateLocalesClass(schema, resolved, getStubContent("locales")));
     models.push(generateEntityBaseModel(
       schema,
       schemas,
@@ -2054,6 +2362,24 @@ function getFactoryPath(factory) {
 }
 
 // src/plugin.ts
+function getExistingMigrationTables(migrationsDir) {
+  const existingTables = /* @__PURE__ */ new Set();
+  if (!existsSync(migrationsDir)) {
+    return existingTables;
+  }
+  try {
+    const files = readdirSync(migrationsDir);
+    const createMigrationPattern = /^\d{4}_\d{2}_\d{2}_\d{6}_create_(.+)_table\.php$/;
+    for (const file of files) {
+      const match = file.match(createMigrationPattern);
+      if (match) {
+        existingTables.add(match[1]);
+      }
+    }
+  } catch {
+  }
+  return existingTables;
+}
 var LARAVEL_CONFIG_SCHEMA = {
   fields: [
     {
@@ -2137,18 +2463,81 @@ function laravelPlugin(options) {
     generate: async (ctx) => {
       const migrationOptions = {
         connection: resolved.connection,
-        timestamp: resolved.timestamp
+        timestamp: resolved.timestamp,
+        customTypes: ctx.customTypes
       };
-      const migrations = generateMigrations(ctx.schemas, migrationOptions);
-      return migrations.map((migration) => ({
-        path: getMigrationPath(migration, resolved.migrationsPath),
-        content: migration.content,
-        type: "migration",
-        metadata: {
-          tableName: migration.tables[0],
-          migrationType: migration.type
+      const outputs = [];
+      const migrationsDir = join(ctx.cwd, resolved.migrationsPath);
+      const existingTables = getExistingMigrationTables(migrationsDir);
+      if (ctx.changes !== void 0) {
+        if (ctx.changes.length === 0) {
+          return outputs;
         }
-      }));
+        const addedSchemaNames = new Set(
+          ctx.changes.filter((c) => c.changeType === "added").map((c) => c.schemaName)
+        );
+        if (addedSchemaNames.size > 0) {
+          const addedSchemas = Object.fromEntries(
+            Object.entries(ctx.schemas).filter(([name]) => addedSchemaNames.has(name))
+          );
+          const createMigrations = generateMigrations(addedSchemas, migrationOptions);
+          for (const migration of createMigrations) {
+            const tableName = migration.tables[0];
+            if (existingTables.has(tableName)) {
+              ctx.logger.debug(`Skipping CREATE for ${tableName} (already exists)`);
+              continue;
+            }
+            outputs.push({
+              path: getMigrationPath(migration, resolved.migrationsPath),
+              content: migration.content,
+              type: "migration",
+              metadata: {
+                tableName,
+                migrationType: "create"
+              }
+            });
+          }
+        }
+        const alterChanges = ctx.changes.filter(
+          (c) => c.changeType === "modified" || c.changeType === "removed"
+        );
+        if (alterChanges.length > 0) {
+          const alterMigrations = generateMigrationsFromChanges(
+            alterChanges,
+            migrationOptions
+          );
+          for (const migration of alterMigrations) {
+            outputs.push({
+              path: getMigrationPath(migration, resolved.migrationsPath),
+              content: migration.content,
+              type: "migration",
+              metadata: {
+                tableName: migration.tables[0],
+                migrationType: migration.type
+              }
+            });
+          }
+        }
+      } else {
+        const migrations = generateMigrations(ctx.schemas, migrationOptions);
+        for (const migration of migrations) {
+          const tableName = migration.tables[0];
+          if (migration.type === "create" && existingTables.has(tableName)) {
+            ctx.logger.debug(`Skipping migration for ${tableName} (already exists)`);
+            continue;
+          }
+          outputs.push({
+            path: getMigrationPath(migration, resolved.migrationsPath),
+            content: migration.content,
+            type: "migration",
+            metadata: {
+              tableName,
+              migrationType: migration.type
+            }
+          });
+        }
+      }
+      return outputs;
     }
   };
   const modelGenerator = {
@@ -2274,4 +2663,4 @@ export {
   generateMigrationsFromChanges,
   laravelPlugin
 };
-//# sourceMappingURL=chunk-52JAFQBQ.js.map
+//# sourceMappingURL=chunk-ILSNN7UV.js.map