nextjs-cms 0.5.9 → 0.5.11

package/dist/core/fields/password.d.ts

@@ -1,109 +1,109 @@
-import type { BaseFieldConfig } from "./field.js";
-import { Field } from "./field.js";
-import { entityKind } from "../helpers.js";
-import * as z from 'zod';
-declare const passwordValidationTypeSchema: z.ZodObject<{
-    regex: z.ZodCustom<RegExp, RegExp>;
-    message: z.ZodString;
-}, z.core.$strict>;
-export type PasswordValidationType = z.infer<typeof passwordValidationTypeSchema>;
-declare const passwordFieldConfigSchema: z.ZodObject<{
-    placeholder: z.ZodOptional<z.ZodString>;
-    minLength: z.ZodOptional<z.ZodNumber>;
-    maxLength: z.ZodOptional<z.ZodNumber>;
-    userGenerated: z.ZodOptional<z.ZodBoolean>;
-    validation: z.ZodOptional<z.ZodObject<{
-        regex: z.ZodCustom<RegExp, RegExp>;
-        message: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-type Config = z.infer<typeof passwordFieldConfigSchema>;
-export declare class PasswordField extends Field<'password', Config> {
-    static readonly [entityKind]: string;
-    readonly maxLength: number | undefined;
-    readonly minLength: number | undefined;
-    readonly placeholder: string | undefined;
-    readonly validation: PasswordValidationType | undefined;
-    constructor(config: BaseFieldConfig<Config>);
-    /**
-     * bcrypt the value
-     */
-    bcryptValue(): Promise<void>;
-    exportForClient(): {
-        maxLength: number | undefined;
-        minLength: number | undefined;
-        placeholder: string | undefined;
-        validation: {
-            regex: RegExp;
-            message: string;
-        } | undefined;
-        type: "password";
-        name: string;
-        label: string;
-        required: boolean;
-        conditionalFields: import("../types.js").ConditionalField[];
-        readonly: boolean;
-        defaultValue: any;
-        value: any;
-    };
-    /**
-     * Get the value of the field
-     */
-    getValue(): string;
-    checkRequired(): void;
-    /**
-     * Prepare the field for submission
-     */
-    prepareForSubmission(): Promise<void>;
-}
-export type PasswordFieldClientConfig = ReturnType<PasswordField['exportForClient']>;
-declare const optionsSchema: z.ZodObject<{
-    placeholder: z.ZodOptional<z.ZodString>;
-    minLength: z.ZodOptional<z.ZodNumber>;
-    maxLength: z.ZodOptional<z.ZodNumber>;
-    userGenerated: z.ZodOptional<z.ZodBoolean>;
-    validation: z.ZodOptional<z.ZodObject<{
-        regex: z.ZodCustom<RegExp, RegExp>;
-        message: z.ZodString;
-    }, z.core.$strict>>;
-    name: z.ZodString;
-    label: z.ZodOptional<z.ZodString>;
-    required: z.ZodOptional<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    order: z.ZodOptional<z.ZodNumber>;
-    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types.js").ConditionalRule, import("../types.js").ConditionalRule>>>;
-    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
-}, z.core.$strict>;
-declare const configSchema: z.ZodObject<{
-    type: z.ZodLiteral<"password">;
-    build: z.ZodFunction<z.core.$ZodFunctionArgs, z.ZodCustom<PasswordField, PasswordField>>;
-    placeholder: z.ZodOptional<z.ZodString>;
-    minLength: z.ZodOptional<z.ZodNumber>;
-    maxLength: z.ZodOptional<z.ZodNumber>;
-    userGenerated: z.ZodOptional<z.ZodBoolean>;
-    validation: z.ZodOptional<z.ZodObject<{
-        regex: z.ZodCustom<RegExp, RegExp>;
-        message: z.ZodString;
-    }, z.core.$strict>>;
-    name: z.ZodString;
-    label: z.ZodOptional<z.ZodString>;
-    required: z.ZodOptional<z.ZodBoolean>;
-    defaultValue: z.ZodOptional<z.ZodAny>;
-    order: z.ZodOptional<z.ZodNumber>;
-    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types.js").ConditionalRule, import("../types.js").ConditionalRule>>>;
-    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
-}, z.core.$strict>;
-/**
- * Password field configuration type
- * This is a plain object that can be serialized and used anywhere
- * The build() method allows creating a PasswordField instance when needed
- */
-export type PasswordFieldConfig = z.infer<typeof configSchema>;
-/**
- * Helper function to create a password field configuration
- * Returns a config object with a build() method that can be serialized and used anywhere
- * @param field
- */
-export declare function passwordField(field: z.infer<typeof optionsSchema>): PasswordFieldConfig;
-export {};
+import type { BaseFieldConfig } from './field.js';
+import { Field } from './field.js';
+import { entityKind } from '../helpers/index.js';
+import * as z from 'zod';
+declare const passwordValidationTypeSchema: z.ZodObject<{
+    regex: z.ZodCustom<RegExp, RegExp>;
+    message: z.ZodString;
+}, z.core.$strict>;
+export type PasswordValidationType = z.infer<typeof passwordValidationTypeSchema>;
+declare const passwordFieldConfigSchema: z.ZodObject<{
+    placeholder: z.ZodOptional<z.ZodString>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    userGenerated: z.ZodOptional<z.ZodBoolean>;
+    validation: z.ZodOptional<z.ZodObject<{
+        regex: z.ZodCustom<RegExp, RegExp>;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type Config = z.infer<typeof passwordFieldConfigSchema>;
+export declare class PasswordField extends Field<'password', Config> {
+    static readonly [entityKind]: string;
+    readonly maxLength: number | undefined;
+    readonly minLength: number | undefined;
+    readonly placeholder: string | undefined;
+    readonly validation: PasswordValidationType | undefined;
+    constructor(config: BaseFieldConfig<Config>);
+    /**
+     * bcrypt the value
+     */
+    bcryptValue(): Promise<void>;
+    exportForClient(): {
+        maxLength: number | undefined;
+        minLength: number | undefined;
+        placeholder: string | undefined;
+        validation: {
+            regex: RegExp;
+            message: string;
+        } | undefined;
+        type: "password";
+        name: string;
+        label: string;
+        required: boolean;
+        conditionalFields: import("../types/index.js").ConditionalField[];
+        readonly: boolean;
+        defaultValue: any;
+        value: any;
+    };
+    /**
+     * Get the value of the field
+     */
+    getValue(): string;
+    checkRequired(): void;
+    /**
+     * Prepare the field for submission
+     */
+    prepareForSubmission(): Promise<void>;
+}
+export type PasswordFieldClientConfig = ReturnType<PasswordField['exportForClient']>;
+declare const optionsSchema: z.ZodObject<{
+    placeholder: z.ZodOptional<z.ZodString>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    userGenerated: z.ZodOptional<z.ZodBoolean>;
+    validation: z.ZodOptional<z.ZodObject<{
+        regex: z.ZodCustom<RegExp, RegExp>;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    order: z.ZodOptional<z.ZodNumber>;
+    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types/index.js").ConditionalRule, import("../types/index.js").ConditionalRule>>>;
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>;
+declare const configSchema: z.ZodObject<{
+    type: z.ZodLiteral<"password">;
+    build: z.ZodFunction<z.core.$ZodFunctionArgs, z.ZodCustom<PasswordField, PasswordField>>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    minLength: z.ZodOptional<z.ZodNumber>;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    userGenerated: z.ZodOptional<z.ZodBoolean>;
+    validation: z.ZodOptional<z.ZodObject<{
+        regex: z.ZodCustom<RegExp, RegExp>;
+        message: z.ZodString;
+    }, z.core.$strict>>;
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    defaultValue: z.ZodOptional<z.ZodAny>;
+    order: z.ZodOptional<z.ZodNumber>;
+    conditionalRules: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types/index.js").ConditionalRule, import("../types/index.js").ConditionalRule>>>;
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>;
+/**
+ * Password field configuration type
+ * This is a plain object that can be serialized and used anywhere
+ * The build() method allows creating a PasswordField instance when needed
+ */
+export type PasswordFieldConfig = z.infer<typeof configSchema>;
+/**
+ * Helper function to create a password field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ * @param field
+ */
+export declare function passwordField(field: z.infer<typeof optionsSchema>): PasswordFieldConfig;
+export {};
 //# sourceMappingURL=password.d.ts.map

package/dist/core/fields/password.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"password.d.ts","sourceRoot":"","sources":["../../../src/core/fields/password.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,EAAE,KAAK,EAAyB,MAAM,SAAS,CAAA;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAEvC,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,QAAA,MAAM,4BAA4B;;;kBAGhC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEjF,QAAA,MAAM,yBAAyB;;;;;;;;;kBAM7B,CAAA;AAEF,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAEvD,qBAAa,aAAc,SAAQ,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC;IACxD,gBAAyB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAkB;IAC/D,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IACxC,QAAQ,CAAC,UAAU,EAAE,sBAAsB,GAAG,SAAS,CAAA;gBAE3C,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC;IAQ3C;;OAEG;IACG,WAAW;IAMD,eAAe;;;;;;;;;;;;;;;;;IAU/B;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB,aAAa;IAWb;;OAEG;IACG,oBAAoB;CAuC7B;AAED,MAAM,MAAM,yBAAyB,GAAG,UAAU,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAA;AAEpF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;kBAGjB,CAAA;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;kBAIhB,CAAA;AAEF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAE9D;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,GAAG,mBAAmB,CAmBvF"}
+{"version":3,"file":"password.d.ts","sourceRoot":"","sources":["../../../src/core/fields/password.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,EAAE,KAAK,EAAyB,MAAM,YAAY,CAAA;AACzD,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAEhD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,QAAA,MAAM,4BAA4B;;;kBAGhC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEjF,QAAA,MAAM,yBAAyB;;;;;;;;;kBAM7B,CAAA;AAEF,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAEvD,qBAAa,aAAc,SAAQ,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC;IACxD,gBAAyB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAkB;IAC/D,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IACxC,QAAQ,CAAC,UAAU,EAAE,sBAAsB,GAAG,SAAS,CAAA;gBAE3C,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC;IAQ3C;;OAEG;IACG,WAAW;IAMD,eAAe;;;;;;;;;;;;;;;;;IAU/B;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB,aAAa;IAWb;;OAEG;IACG,oBAAoB;CAuC7B;AAED,MAAM,MAAM,yBAAyB,GAAG,UAAU,CAAC,aAAa,CAAC,iBAAiB,CAAC,CAAC,CAAA;AAEpF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;kBAGjB,CAAA;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;kBAIhB,CAAA;AAEF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAE9D;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,GAAG,mBAAmB,CAmBvF"}

package/dist/core/fields/password.js

@@ -1,133 +1,133 @@
-import { Field, baseFieldConfigSchema } from "./field.js";
-import { entityKind } from "../helpers.js";
-import bcrypt from 'bcrypt';
-import * as z from 'zod';
-const passwordValidationTypeSchema = z.strictObject({
-    regex: z.custom().describe('The regex pattern for validation'),
-    message: z.string().describe('The error message if validation fails'),
-});
-const passwordFieldConfigSchema = z.strictObject({
-    placeholder: z.string().optional().describe('The placeholder text for the field'),
-    minLength: z.number().optional().describe('The minimum length of the field value'),
-    maxLength: z.number().optional().describe('The maximum length of the field value'),
-    userGenerated: z.boolean().optional().describe('Whether the field is user generated'),
-    validation: passwordValidationTypeSchema.optional().describe('Validation rules for the password'),
-});
-export class PasswordField extends Field {
-    static [entityKind] = 'PasswordField';
-    maxLength;
-    minLength;
-    placeholder;
-    validation;
-    constructor(config) {
-        super(config, 'password');
-        this.maxLength = config.maxLength;
-        this.minLength = config.minLength;
-        this.placeholder = config.placeholder;
-        this.validation = config.validation;
-    }
-    /**
-     * bcrypt the value
-     */
-    async bcryptValue() {
-        if (this.value) {
-            this.value = await bcrypt.hash(this.value, 10);
-        }
-    }
-    exportForClient() {
-        return {
-            ...super.exportForClient(),
-            maxLength: this.maxLength,
-            minLength: this.minLength,
-            placeholder: this.placeholder,
-            validation: this.validation,
-        };
-    }
-    /**
-     * Get the value of the field
-     */
-    getValue() {
-        return this.value;
-    }
-    checkRequired() {
-        /**
-         * Check if the field is required
-         */
-        if (this.adminGenerated && this.required) {
-            if (!this.value || this.value.trim().length === 0) {
-                throw new Error(`Field ${this.label} is required`);
-            }
-        }
-    }
-    /**
-     * Prepare the field for submission
-     */
-    async prepareForSubmission() {
-        /**
-         * Validate the value
-         */
-        if (this.validation && this.validation.regex && this.validation.message) {
-            /**
-             * Check the provided regex
-             */
-            if (!this.validation.regex.test(this.value)) {
-                /**
-                 * Display the provided message
-                 */
-                throw new Error(`Field ${this.label}: ${this.validation.message}`);
-            }
-        }
-        /**
-         * Check minimum length
-         */
-        if (this.minLength) {
-            if (this.minLength > this.value.length) {
-                throw new Error(`Field ${this.label} must be at least ${this.minLength} characters long`);
-            }
-        }
-        /**
-         * Check maximum length
-         */
-        if (this.maxLength) {
-            if (this.maxLength < this.value.length) {
-                throw new Error(`Field ${this.label} must be at most ${this.maxLength} characters long`);
-            }
-        }
-        /**
-         * bcrypt the value, do this only once for a field
-         */
-        await this.bcryptValue();
-    }
-}
-const optionsSchema = z.strictObject({
-    ...baseFieldConfigSchema.shape,
-    ...passwordFieldConfigSchema.shape,
-});
-const configSchema = z.strictObject({
-    ...optionsSchema.shape,
-    type: z.literal('password').describe('The type of the field'),
-    build: z.function().output(z.instanceof(PasswordField)).describe('Build a PasswordField instance from this config'),
-});
-/**
- * Helper function to create a password field configuration
- * Returns a config object with a build() method that can be serialized and used anywhere
- * @param field
- */
-export function passwordField(field) {
-    /**
-     * Validate the field config
-     */
-    const result = optionsSchema.safeParse(field);
-    if (!result.success) {
-        throw new Error(`[Field: ${field.name}]: ${z.prettifyError(result.error)}`);
-    }
-    const config = {
-        ...field,
-        type: 'password',
-        build() {
-            // Use the original field config directly (it doesn't have build() method)
-            return new PasswordField(field);
-        },
-    };
-    return config;
-}
+import { Field, baseFieldConfigSchema } from './field.js';
+import { entityKind } from '../helpers/index.js';
+import bcrypt from 'bcrypt';
+import * as z from 'zod';
+const passwordValidationTypeSchema = z.strictObject({
+    regex: z.custom().describe('The regex pattern for validation'),
+    message: z.string().describe('The error message if validation fails'),
+});
+const passwordFieldConfigSchema = z.strictObject({
+    placeholder: z.string().optional().describe('The placeholder text for the field'),
+    minLength: z.number().optional().describe('The minimum length of the field value'),
+    maxLength: z.number().optional().describe('The maximum length of the field value'),
+    userGenerated: z.boolean().optional().describe('Whether the field is user generated'),
+    validation: passwordValidationTypeSchema.optional().describe('Validation rules for the password'),
+});
+export class PasswordField extends Field {
+    static [entityKind] = 'PasswordField';
+    maxLength;
+    minLength;
+    placeholder;
+    validation;
+    constructor(config) {
+        super(config, 'password');
+        this.maxLength = config.maxLength;
+        this.minLength = config.minLength;
+        this.placeholder = config.placeholder;
+        this.validation = config.validation;
+    }
+    /**
+     * bcrypt the value
+     */
+    async bcryptValue() {
+        if (this.value) {
+            this.value = await bcrypt.hash(this.value, 10);
+        }
+    }
+    exportForClient() {
+        return {
+            ...super.exportForClient(),
+            maxLength: this.maxLength,
+            minLength: this.minLength,
+            placeholder: this.placeholder,
+            validation: this.validation,
+        };
+    }
+    /**
+     * Get the value of the field
+     */
+    getValue() {
+        return this.value;
+    }
+    checkRequired() {
+        /**
+         * Check if the field is required
+         */
+        if (this.adminGenerated && this.required) {
+            if (!this.value || this.value.trim().length === 0) {
+                throw new Error(`Field ${this.label} is required`);
+            }
+        }
+    }
+    /**
+     * Prepare the field for submission
+     */
+    async prepareForSubmission() {
+        /**
+         * Validate the value
+         */
+        if (this.validation && this.validation.regex && this.validation.message) {
+            /**
+             * Check the provided regex
+             */
+            if (!this.validation.regex.test(this.value)) {
+                /**
+                 * Display the provided message
+                 */
+                throw new Error(`Field ${this.label}: ${this.validation.message}`);
+            }
+        }
+        /**
+         * Check minimum length
+         */
+        if (this.minLength) {
+            if (this.minLength > this.value.length) {
+                throw new Error(`Field ${this.label} must be at least ${this.minLength} characters long`);
+            }
+        }
+        /**
+         * Check maximum length
+         */
+        if (this.maxLength) {
+            if (this.maxLength < this.value.length) {
+                throw new Error(`Field ${this.label} must be at most ${this.maxLength} characters long`);
+            }
+        }
+        /**
+         * bcrypt the value, do this only once for a field
+         */
+        await this.bcryptValue();
+    }
+}
+const optionsSchema = z.strictObject({
+    ...baseFieldConfigSchema.shape,
+    ...passwordFieldConfigSchema.shape,
+});
+const configSchema = z.strictObject({
+    ...optionsSchema.shape,
+    type: z.literal('password').describe('The type of the field'),
+    build: z.function().output(z.instanceof(PasswordField)).describe('Build a PasswordField instance from this config'),
+});
+/**
+ * Helper function to create a password field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ * @param field
+ */
+export function passwordField(field) {
+    /**
+     * Validate the field config
+     */
+    const result = optionsSchema.safeParse(field);
+    if (!result.success) {
+        throw new Error(`[Field: ${field.name}]: ${z.prettifyError(result.error)}`);
+    }
+    const config = {
+        ...field,
+        type: 'password',
+        build() {
+            // Use the original field config directly (it doesn't have build() method)
+            return new PasswordField(field);
+        },
+    };
+    return config;
+}