nextjs-cms 0.7.8 → 0.7.10

package/dist/cli/lib/update-sections.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update-sections.d.ts","sourceRoot":"","sources":["../../../src/cli/lib/update-sections.ts"],"names":[],"mappings":"AAgjCA,wBAAsB,cAAc,CAAC,SAAS,UAAQ,iBAoBrD"}
+{"version":3,"file":"update-sections.d.ts","sourceRoot":"","sources":["../../../src/cli/lib/update-sections.ts"],"names":[],"mappings":"AAolCA,wBAAsB,cAAc,CAAC,SAAS,UAAQ,iBAoBrD"}

package/dist/cli/lib/update-sections.js

@@ -11,7 +11,7 @@ import { FileField } from '../../core/fields/index.js';
 import chalk from 'chalk';
 import { intro, select, spinner, log } from '@clack/prompts';
 import { MysqlTableChecker } from '../../core/db/index.js';
-import { generateDrizzleSchema } from '../utils/schema-generator.js';
+import { generateDrizzleSchema, resolveCaseStyleFns } from '../utils/schema-generator.js';
 import { addTableKeys } from '../utils/add-table-keys.js';
 function generateFieldSQL(input) {
     let fieldSQL = `\`${input.name}\` `;
@@ -525,8 +525,9 @@ const main = async (s) => {
     else {
         console.log(chalk.yellow(`Schema generation is disabled. Skipping Drizzle schema generation.`));
     }
+    const caseStyleFns = resolveCaseStyleFns(cmsConfig.schemaGeneration.drizzle.naming);
     const drizzleTableSchemas = [];
-    const drizzleColumnTypes = ['mysqlTable'];
+    const drizzleImports = new Set(['mysqlTable']);
     let sections = [];
     const desiredTables = [];
     let existingTables = [];
@@ -556,17 +557,13 @@ const main = async (s) => {
         /**
          * Generate the Drizzle schema for the table
          */
-        const drizzleSchema = await generateDrizzleSchema({
+        const drizzleSchema = generateDrizzleSchema({
             name: s.db.table,
             fields: s.fieldConfigs,
             identifier: s.db.identifier,
-        });
+        }, caseStyleFns);
         drizzleTableSchemas.push(drizzleSchema.schema);
-        drizzleSchema.columnTypes.forEach((type) => {
-            if (!drizzleColumnTypes.includes(type)) {
-                drizzleColumnTypes.push(type);
-            }
-        });
+        drizzleSchema.drizzleImports.forEach((type) => drizzleImports.add(type));
         desiredTables.push({
             name: s.db.table,
             fields: s.fields,
@@ -614,6 +611,17 @@ const main = async (s) => {
                      */
                     primaryKey: [referenceIdFieldConfig, selectIdFieldConfig],
                 });
+                const destDbFields = [
+                    { name: field.destinationDb.itemIdentifier, type: 'text', required: true },
+                    { name: field.destinationDb.selectIdentifier, type: 'text', required: true },
+                ];
+                const destDbSchema = generateDrizzleSchema({
+                    name: field.destinationDb.table,
+                    fields: destDbFields,
+                    compositePrimaryKey: destDbFields,
+                }, caseStyleFns);
+                drizzleTableSchemas.push(destDbSchema.schema);
+                destDbSchema.drizzleImports.forEach((type) => drizzleImports.add(type));
             }
         }
         /**
@@ -654,6 +662,32 @@ const main = async (s) => {
                 identifier: photoField,
                 primaryKey: [photoField],
             });
+            const gallerySchema = generateDrizzleSchema({
+                name: gallery.db.tableName,
+                fields: [
+                    {
+                        name: gallery.db.referenceIdentifierField || 'reference_id',
+                        type: 'text',
+                        required: true,
+                    },
+                    {
+                        name: gallery.db.photoNameField || 'photo',
+                        type: 'text',
+                        required: true,
+                    },
+                    {
+                        name: gallery.db.metaField || 'meta',
+                        type: 'textarea',
+                        required: false,
+                    },
+                ],
+                identifier: {
+                    name: gallery.db.photoNameField || 'photo',
+                    type: 'text',
+                },
+            }, caseStyleFns);
+            drizzleTableSchemas.push(gallerySchema.schema);
+            gallerySchema.drizzleImports.forEach((type) => drizzleImports.add(type));
         }
     }
     /**
@@ -667,9 +701,9 @@ const main = async (s) => {
             fs.mkdirSync(schemaOutDir, { recursive: true });
         }
         /**
-         * Append the Drizzle column types to the schema file
+         * Append the Drizzle imports to the schema file
          */
-        fs.appendFileSync(schemaFilePath, 'import {' + drizzleColumnTypes.join(',') + "} from 'drizzle-orm/mysql-core'\n\n");
+        fs.appendFileSync(schemaFilePath, 'import {' + [...drizzleImports].join(',') + "} from 'drizzle-orm/mysql-core'\n\n");
         /**
          * Append the Drizzle table schemas to the schema file
          */

package/dist/cli/utils/schema-generator.d.ts

@@ -1,10 +1,26 @@
 import type { FieldConfig } from '../../core/fields/index.js';
+export interface CaseStyleFns {
+    tableCaseStyleFn: (str: string) => string;
+    columnCaseStyleFn: (str: string) => string;
+}
+export interface NamingConfig {
+    tables: 'camelCase' | 'snakeCase' | 'pascalCase';
+    columns: 'camelCase' | 'snakeCase' | 'pascalCase';
+}
+/**
+ * Resolves case-style functions from the naming configuration.
+ * Centralises the switch logic that was previously duplicated across generators.
+ */
+export declare function resolveCaseStyleFns(naming: NamingConfig): CaseStyleFns;
 export declare function generateDrizzleSchema(table: {
     name: string;
     fields: FieldConfig[];
-    identifier: FieldConfig;
-}): Promise<{
+    identifier?: FieldConfig;
+    compositePrimaryKey?: {
+        name: string;
+    }[];
+}, caseStyleFns: CaseStyleFns): {
     schema: string;
-    columnTypes: string[];
-}>;
+    drizzleImports: string[];
+};
 //# sourceMappingURL=schema-generator.d.ts.map

package/dist/cli/utils/schema-generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-generator.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/schema-generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAoB7D,wBAAsB,qBAAqB,CAAC,KAAK,EAAE;IAC/C,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,WAAW,EAAE,CAAA;IACrB,UAAU,EAAE,WAAW,CAAA;CAC1B,GAAG,OAAO,CAAC;IACR,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,EAAE,CAAA;CACxB,CAAC,CAqKD"}
+{"version":3,"file":"schema-generator.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/schema-generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAoB7D,MAAM,WAAW,YAAY;IACzB,gBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;IACzC,iBAAiB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAA;CAC7C;AAED,MAAM,WAAW,YAAY;IACzB,MAAM,EAAE,WAAW,GAAG,WAAW,GAAG,YAAY,CAAA;IAChD,OAAO,EAAE,WAAW,GAAG,WAAW,GAAG,YAAY,CAAA;CACpD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CA8BtE;AAED,wBAAgB,qBAAqB,CACjC,KAAK,EAAE;IACH,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,WAAW,EAAE,CAAA;IACrB,UAAU,CAAC,EAAE,WAAW,CAAA;IACxB,mBAAmB,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CAC3C,EACD,YAAY,EAAE,YAAY,GAC3B;IACC,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,EAAE,CAAA;CAC3B,CAwIA"}

package/dist/cli/utils/schema-generator.js

@@ -13,12 +13,13 @@ function toSnakeCase(str) {
         .replace(/^_/, '') // Remove leading underscore if any
         .toLowerCase();
 }
-export async function generateDrizzleSchema(table) {
-    const { getCMSConfig } = await import('../../core/config/index.js');
+/**
+ * Resolves case-style functions from the naming configuration.
+ * Centralises the switch logic that was previously duplicated across generators.
+ */
+export function resolveCaseStyleFns(naming) {
     let tableCaseStyleFn;
-    let columnCaseStyleFn;
-    const lzConfig = await getCMSConfig();
-    switch (lzConfig.schemaGeneration.drizzle.naming.tables) {
+    switch (naming.tables) {
         case 'snakeCase':
             tableCaseStyleFn = toSnakeCase;
             break;
@@ -30,7 +31,8 @@ export async function generateDrizzleSchema(table) {
             tableCaseStyleFn = toPascalCase;
             break;
     }
-    switch (lzConfig.schemaGeneration.drizzle.naming.columns) {
+    let columnCaseStyleFn;
+    switch (naming.columns) {
         case 'snakeCase':
             columnCaseStyleFn = toSnakeCase;
             break;
@@ -42,12 +44,11 @@ export async function generateDrizzleSchema(table) {
             columnCaseStyleFn = toCamelCase;
             break;
     }
-    /**
-     * This function generates a Drizzle schema for a given table.
-     * It takes a table object with a name, inputs (fields), and an identifier field.
-     * It returns an object containing the generated schema as a string and an array of column types.
-     */
-    const drizzleColumnTypes = [];
+    return { tableCaseStyleFn, columnCaseStyleFn };
+}
+export function generateDrizzleSchema(table, caseStyleFns) {
+    const { tableCaseStyleFn, columnCaseStyleFn } = caseStyleFns;
+    const drizzleImports = [];
     let schema = '';
     const schemaName = tableCaseStyleFn(`${table.name}_table`);
     schema += `export const ${schemaName} = mysqlTable('${table.name}', {\n`;
@@ -58,7 +59,6 @@ export async function generateDrizzleSchema(table) {
             continue;
         let columnType;
         let drizzleColumnType;
-        // let columnOptions = ''
         switch (input.type) {
             case 'text':
                 columnType = `varchar('${input.name}', { length: ${input.maxLength ?? 255} })`;
@@ -145,27 +145,30 @@ export async function generateDrizzleSchema(table) {
         if (input.required) {
             columnType += `.notNull()`;
         }
-        if (input === table.identifier) {
+        if (table.identifier && input === table.identifier) {
             columnType += `.primaryKey()`;
         }
         /*if (input.type === 'date') {
             columnType += `.defaultNow()`
         }*/
         schema += `    ${columnCaseStyleFn(input.name)}: ${columnType},\n`;
-        /**
-         * First, let's check if the column type is already in the drizzleColumnTypes array
-         */
-        if (drizzleColumnType && !drizzleColumnTypes.includes(drizzleColumnType)) {
-            /**
-             * If it's not, add it to the array
-             */
-            drizzleColumnTypes.push(drizzleColumnType);
+        if (drizzleColumnType && !drizzleImports.includes(drizzleColumnType)) {
+            drizzleImports.push(drizzleColumnType);
         }
     }
     schema = schema.slice(0, -2); // Remove the last comma and newline
-    schema += `\n});\n\n`;
+    if (table.compositePrimaryKey && table.compositePrimaryKey.length > 1) {
+        const pkCols = table.compositePrimaryKey.map((f) => `table.${columnCaseStyleFn(f.name)}`).join(', ');
+        schema += `\n}, (table) => [primaryKey({ columns: [${pkCols}] })]);\n\n`;
+        if (!drizzleImports.includes('primaryKey')) {
+            drizzleImports.push('primaryKey');
+        }
+    }
+    else {
+        schema += `\n});\n\n`;
+    }
     return {
         schema: schema,
-        columnTypes: drizzleColumnTypes,
+        drizzleImports,
     };
 }

package/dist/core/sections/category.d.ts

@@ -118,9 +118,27 @@ declare const optionsSchema: z.ZodObject<{
      */
     allowRecursiveDelete: z.ZodOptional<z.ZodBoolean>;
     fields: z.ZodUnion<[z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>, z.ZodArray<z.ZodCustom<FieldGroupConfig, FieldGroupConfig>>]>;
-    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     name: z.ZodString;
-    order: z.ZodNumber;
+    gallery: z.ZodOptional<z.ZodObject<{
+        db: z.ZodObject<{
+            tableName: z.ZodString;
+            identifierField: z.ZodOptional<z.ZodString>;
+            photoNameField: z.ZodOptional<z.ZodString>;
+            metaField: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        watermark: z.ZodOptional<z.ZodBoolean>;
+        thumbnail: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            fit: z.ZodEnum<{
+                cover: "cover";
+                contain: "contain";
+            }>;
+            quality: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    icon: z.ZodOptional<z.ZodString>;
     db: z.ZodObject<{
         table: z.ZodString;
         identifier: z.ZodOptional<z.ZodCustom<FieldConfig, FieldConfig>>;
@@ -144,26 +162,8 @@ declare const optionsSchema: z.ZodObject<{
             name: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
     }, z.core.$strict>;
-    icon: z.ZodOptional<z.ZodString>;
-    gallery: z.ZodOptional<z.ZodObject<{
-        db: z.ZodObject<{
-            tableName: z.ZodString;
-            identifierField: z.ZodOptional<z.ZodString>;
-            photoNameField: z.ZodOptional<z.ZodString>;
-            metaField: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>;
-        watermark: z.ZodOptional<z.ZodBoolean>;
-        thumbnail: z.ZodOptional<z.ZodObject<{
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-            fit: z.ZodEnum<{
-                cover: "cover";
-                contain: "contain";
-            }>;
-            quality: z.ZodNumber;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
     variants: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types/index.js").Variant, import("../types/index.js").Variant>>>;
+    order: z.ZodNumber;
     hooks: z.ZodOptional<z.ZodCustom<import("./section.js").Hooks, import("./section.js").Hooks>>;
 }, z.core.$strict>;
 export declare const categorySectionConfigSchema: z.ZodObject<{
@@ -218,9 +218,27 @@ export declare const categorySectionConfigSchema: z.ZodObject<{
      * @default false
      */
     allowRecursiveDelete: z.ZodOptional<z.ZodBoolean>;
-    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     name: z.ZodString;
-    order: z.ZodNumber;
+    gallery: z.ZodOptional<z.ZodObject<{
+        db: z.ZodObject<{
+            tableName: z.ZodString;
+            identifierField: z.ZodOptional<z.ZodString>;
+            photoNameField: z.ZodOptional<z.ZodString>;
+            metaField: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        watermark: z.ZodOptional<z.ZodBoolean>;
+        thumbnail: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            fit: z.ZodEnum<{
+                cover: "cover";
+                contain: "contain";
+            }>;
+            quality: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    icon: z.ZodOptional<z.ZodString>;
     db: z.ZodObject<{
         table: z.ZodString;
         identifier: z.ZodOptional<z.ZodCustom<FieldConfig, FieldConfig>>;
@@ -244,26 +262,8 @@ export declare const categorySectionConfigSchema: z.ZodObject<{
             name: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
     }, z.core.$strict>;
-    icon: z.ZodOptional<z.ZodString>;
-    gallery: z.ZodOptional<z.ZodObject<{
-        db: z.ZodObject<{
-            tableName: z.ZodString;
-            identifierField: z.ZodOptional<z.ZodString>;
-            photoNameField: z.ZodOptional<z.ZodString>;
-            metaField: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>;
-        watermark: z.ZodOptional<z.ZodBoolean>;
-        thumbnail: z.ZodOptional<z.ZodObject<{
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-            fit: z.ZodEnum<{
-                cover: "cover";
-                contain: "contain";
-            }>;
-            quality: z.ZodNumber;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
     variants: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types/index.js").Variant, import("../types/index.js").Variant>>>;
+    order: z.ZodNumber;
     hooks: z.ZodOptional<z.ZodCustom<import("./section.js").Hooks, import("./section.js").Hooks>>;
 }, z.core.$strict>;
 export type CategorySectionOptions = z.infer<typeof optionsSchema>;

package/dist/core/sections/hasItems.d.ts

@@ -481,9 +481,27 @@ declare const optionsSchema: z.ZodObject<{
     }>>;
     generateQR: z.ZodOptional<z.ZodBoolean>;
     fields: z.ZodUnion<[z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>, z.ZodArray<z.ZodCustom<FieldGroupConfig, FieldGroupConfig>>]>;
-    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     name: z.ZodString;
-    order: z.ZodNumber;
+    gallery: z.ZodOptional<z.ZodObject<{
+        db: z.ZodObject<{
+            tableName: z.ZodString;
+            identifierField: z.ZodOptional<z.ZodString>;
+            photoNameField: z.ZodOptional<z.ZodString>;
+            metaField: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        watermark: z.ZodOptional<z.ZodBoolean>;
+        thumbnail: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            fit: z.ZodEnum<{
+                cover: "cover";
+                contain: "contain";
+            }>;
+            quality: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    icon: z.ZodOptional<z.ZodString>;
     db: z.ZodObject<{
         table: z.ZodString;
         identifier: z.ZodOptional<z.ZodCustom<FieldConfig, FieldConfig>>;
@@ -507,26 +525,8 @@ declare const optionsSchema: z.ZodObject<{
             name: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
     }, z.core.$strict>;
-    icon: z.ZodOptional<z.ZodString>;
-    gallery: z.ZodOptional<z.ZodObject<{
-        db: z.ZodObject<{
-            tableName: z.ZodString;
-            identifierField: z.ZodOptional<z.ZodString>;
-            photoNameField: z.ZodOptional<z.ZodString>;
-            metaField: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>;
-        watermark: z.ZodOptional<z.ZodBoolean>;
-        thumbnail: z.ZodOptional<z.ZodObject<{
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-            fit: z.ZodEnum<{
-                cover: "cover";
-                contain: "contain";
-            }>;
-            quality: z.ZodNumber;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
     variants: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types/index.js").Variant, import("../types/index.js").Variant>>>;
+    order: z.ZodNumber;
     hooks: z.ZodOptional<z.ZodCustom<import("./section.js").Hooks, import("./section.js").Hooks>>;
 }, z.core.$strict>;
 declare const hasItemsSectionConfigSchema: z.ZodObject<{
@@ -757,9 +757,27 @@ declare const hasItemsSectionConfigSchema: z.ZodObject<{
         adminGenerated?: boolean | "readonly" | undefined;
     }>>;
     generateQR: z.ZodOptional<z.ZodBoolean>;
-    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     name: z.ZodString;
-    order: z.ZodNumber;
+    gallery: z.ZodOptional<z.ZodObject<{
+        db: z.ZodObject<{
+            tableName: z.ZodString;
+            identifierField: z.ZodOptional<z.ZodString>;
+            photoNameField: z.ZodOptional<z.ZodString>;
+            metaField: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        watermark: z.ZodOptional<z.ZodBoolean>;
+        thumbnail: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            fit: z.ZodEnum<{
+                cover: "cover";
+                contain: "contain";
+            }>;
+            quality: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    icon: z.ZodOptional<z.ZodString>;
     db: z.ZodObject<{
         table: z.ZodString;
         identifier: z.ZodOptional<z.ZodCustom<FieldConfig, FieldConfig>>;
@@ -783,26 +801,8 @@ declare const hasItemsSectionConfigSchema: z.ZodObject<{
             name: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
     }, z.core.$strict>;
-    icon: z.ZodOptional<z.ZodString>;
-    gallery: z.ZodOptional<z.ZodObject<{
-        db: z.ZodObject<{
-            tableName: z.ZodString;
-            identifierField: z.ZodOptional<z.ZodString>;
-            photoNameField: z.ZodOptional<z.ZodString>;
-            metaField: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>;
-        watermark: z.ZodOptional<z.ZodBoolean>;
-        thumbnail: z.ZodOptional<z.ZodObject<{
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-            fit: z.ZodEnum<{
-                cover: "cover";
-                contain: "contain";
-            }>;
-            quality: z.ZodNumber;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
     variants: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types/index.js").Variant, import("../types/index.js").Variant>>>;
+    order: z.ZodNumber;
     hooks: z.ZodOptional<z.ZodCustom<import("./section.js").Hooks, import("./section.js").Hooks>>;
 }, z.core.$strict>;
 export type HasItemsSectionOptions = z.infer<typeof optionsSchema>;

package/dist/core/sections/section.d.ts

@@ -65,9 +65,27 @@ export declare const baseSectionOptionsSchema: z.ZodObject<{
  */
 export declare const baseHelperFunctionOptionsSchema: z.ZodObject<{
     fields: z.ZodUnion<[z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>, z.ZodArray<z.ZodCustom<FieldGroupConfig, FieldGroupConfig>>]>;
-    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     name: z.ZodString;
-    order: z.ZodNumber;
+    gallery: z.ZodOptional<z.ZodObject<{
+        db: z.ZodObject<{
+            tableName: z.ZodString;
+            identifierField: z.ZodOptional<z.ZodString>;
+            photoNameField: z.ZodOptional<z.ZodString>;
+            metaField: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        watermark: z.ZodOptional<z.ZodBoolean>;
+        thumbnail: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            fit: z.ZodEnum<{
+                cover: "cover";
+                contain: "contain";
+            }>;
+            quality: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    icon: z.ZodOptional<z.ZodString>;
     db: z.ZodObject<{
         table: z.ZodString;
         identifier: z.ZodOptional<z.ZodCustom<FieldConfig, FieldConfig>>;
@@ -91,26 +109,8 @@ export declare const baseHelperFunctionOptionsSchema: z.ZodObject<{
             name: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
     }, z.core.$strict>;
-    icon: z.ZodOptional<z.ZodString>;
-    gallery: z.ZodOptional<z.ZodObject<{
-        db: z.ZodObject<{
-            tableName: z.ZodString;
-            identifierField: z.ZodOptional<z.ZodString>;
-            photoNameField: z.ZodOptional<z.ZodString>;
-            metaField: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>;
-        watermark: z.ZodOptional<z.ZodBoolean>;
-        thumbnail: z.ZodOptional<z.ZodObject<{
-            width: z.ZodNumber;
-            height: z.ZodNumber;
-            fit: z.ZodEnum<{
-                cover: "cover";
-                contain: "contain";
-            }>;
-            quality: z.ZodNumber;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
     variants: z.ZodOptional<z.ZodArray<z.ZodCustom<Variant, Variant>>>;
+    order: z.ZodNumber;
     hooks: z.ZodOptional<z.ZodCustom<Hooks, Hooks>>;
 }, z.core.$strict>;
 export declare function validateSectionConfig(config: BaseSectionOptions): void;

package/dist/core/sections/simple.d.ts

@@ -23,10 +23,7 @@ declare const optionsSchema: z.ZodObject<{
         table: z.ZodString;
     }, z.core.$strict>;
     fields: z.ZodUnion<[z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>, z.ZodArray<z.ZodCustom<FieldGroupConfig, FieldGroupConfig>>]>;
-    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     name: z.ZodString;
-    order: z.ZodNumber;
-    icon: z.ZodOptional<z.ZodString>;
     gallery: z.ZodOptional<z.ZodObject<{
         db: z.ZodObject<{
             tableName: z.ZodString;
@@ -45,7 +42,10 @@ declare const optionsSchema: z.ZodObject<{
             quality: z.ZodNumber;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
+    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    icon: z.ZodOptional<z.ZodString>;
     variants: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types/index.js").Variant, import("../types/index.js").Variant>>>;
+    order: z.ZodNumber;
     hooks: z.ZodOptional<z.ZodCustom<import("./section.js").Hooks, import("./section.js").Hooks>>;
 }, z.core.$strict>;
 declare const simpleSectionConfigSchema: z.ZodObject<{
@@ -57,10 +57,7 @@ declare const simpleSectionConfigSchema: z.ZodObject<{
     db: z.ZodObject<{
         table: z.ZodString;
     }, z.core.$strict>;
-    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     name: z.ZodString;
-    order: z.ZodNumber;
-    icon: z.ZodOptional<z.ZodString>;
     gallery: z.ZodOptional<z.ZodObject<{
         db: z.ZodObject<{
             tableName: z.ZodString;
@@ -79,7 +76,10 @@ declare const simpleSectionConfigSchema: z.ZodObject<{
             quality: z.ZodNumber;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
+    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    icon: z.ZodOptional<z.ZodString>;
     variants: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types/index.js").Variant, import("../types/index.js").Variant>>>;
+    order: z.ZodNumber;
     hooks: z.ZodOptional<z.ZodCustom<import("./section.js").Hooks, import("./section.js").Hooks>>;
 }, z.core.$strict>;
 export type SimpleSectionOptions = z.infer<typeof optionsSchema>;

package/dist/translations/base/en.d.ts

@@ -248,6 +248,7 @@ declare const _default: {
     readonly log: "Log";
     readonly logs: "Logs";
     readonly select: "Select";
+    readonly selectOptions: "Select options";
     readonly settings: "Settings";
     readonly deleteItemText: "Are you sure you want to delete this item?";
     readonly deleteEmailText: "Are you sure you want to delete this email account?";
@@ -429,6 +430,21 @@ declare const _default: {
     readonly sqlQueryNotDefined: "SQL query is not defined";
     readonly galleryTableNotSetUp: "Gallery table is not set up correctly, gallery photos were not saved.";
     readonly useVideoApiRoute: "Please use the /api/video route";
+    readonly searchDots: "Search...";
+    readonly noItemFound: "No item found";
+    readonly searchOptionsDots: "Search options...";
+    readonly availableOptions: "Available options";
+    readonly searchThroughOptions: "Search through available options";
+    readonly filterOptionsHint: "Type to filter options. Use arrow keys to navigate results.";
+    readonly openMainMenu: "Open main menu";
+    readonly openUserMenu: "Open user menu";
+    readonly profileImage: "Profile image";
+    readonly logo: "Logo";
+    readonly newImage: "New image";
+    readonly autoGeneratedFromLinkedField: "Auto-generated from linked field";
+    readonly clear: "Clear";
+    readonly close: "Close";
+    readonly clearAllSelectedOptions: "Clear all {count} selected options";
 };
 export default _default;
 //# sourceMappingURL=en.d.ts.map

package/dist/translations/base/en.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../../src/translations/base/en.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBA2cU"}
+{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../../src/translations/base/en.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wBA6dU"}

package/dist/translations/base/en.js

@@ -248,6 +248,7 @@ export default {
     log: 'Log',
     logs: 'Logs',
     select: 'Select',
+    selectOptions: 'Select options',
     settings: 'Settings',
     deleteItemText: 'Are you sure you want to delete this item?',
     deleteEmailText: 'Are you sure you want to delete this email account?',
@@ -442,4 +443,20 @@ export default {
     galleryTableNotSetUp: 'Gallery table is not set up correctly, gallery photos were not saved.',
     // Server Action Errors
     useVideoApiRoute: 'Please use the /api/video route',
+    // UI / Accessibility
+    searchDots: 'Search...',
+    noItemFound: 'No item found',
+    searchOptionsDots: 'Search options...',
+    availableOptions: 'Available options',
+    searchThroughOptions: 'Search through available options',
+    filterOptionsHint: 'Type to filter options. Use arrow keys to navigate results.',
+    openMainMenu: 'Open main menu',
+    openUserMenu: 'Open user menu',
+    profileImage: 'Profile image',
+    logo: 'Logo',
+    newImage: 'New image',
+    autoGeneratedFromLinkedField: 'Auto-generated from linked field',
+    clear: 'Clear',
+    close: 'Close',
+    clearAllSelectedOptions: 'Clear all {count} selected options',
 };