nextjs-cms 0.0.1 → 0.5.2

package/dist/core/fields/textArea.js

@@ -0,0 +1,126 @@
+import { Field, baseFieldConfigSchema } from './field';
+import { entityKind } from '../helpers';
+import * as z from 'zod';
+import { escapeHTML } from '../security/dom';
+const configSchema = 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'),
+    /**
+     * Whether to sanitize the value before saving it to the database.
+     * If true, the value will be escaped to prevent XSS attacks.
+     * If false, the value will be saved as is (raw input).
+     * @default false
+     */
+    sanitize: z.boolean().optional().describe('Sanitize the value before saving'),
+});
+export class TextAreaField extends Field {
+    static [entityKind] = 'TextAreaField';
+    maxLength;
+    minLength;
+    placeholder;
+    sanitize;
+    constructor(config) {
+        super(config, 'textarea');
+        this.maxLength = config.maxLength;
+        this.minLength = config.minLength;
+        this.placeholder = config.placeholder;
+        this.sanitize = config.sanitize ?? false;
+    }
+    exportForClient() {
+        return {
+            ...super.exportForClient(),
+            maxLength: this.maxLength,
+            minLength: this.minLength,
+            placeholder: this.placeholder,
+            sanitize: this.sanitize,
+        };
+    }
+    /**
+     * Sanitize the value
+     */
+    sanitizeValue() {
+        /**
+         * Check if the value is not undefined
+         */
+        if (this.value !== undefined && this.sanitize) {
+            /**
+             * Sanitize the value
+             */
+            this.value = escapeHTML(this.value);
+        }
+    }
+    /**
+     * Get the value of the field
+     */
+    getValue() {
+        return this.value;
+    }
+    checkRequired() {
+        /**
+         * Check if the field is required
+         */
+        if (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() {
+        /**
+         * Sanitize the value
+         */
+        this.sanitizeValue();
+        /**
+         * 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`);
+            }
+        }
+    }
+}
+const optionsSchema = z.strictObject({
+    ...baseFieldConfigSchema.shape,
+    ...configSchema.shape,
+});
+const textAreaFieldConfigSchema = z.strictObject({
+    ...optionsSchema.shape,
+    type: z.literal('textarea').describe('The type of the field'),
+    build: z.function().output(z.instanceof(TextAreaField)).describe('Build a TextAreaField instance from this config'),
+});
+/**
+ * Helper function to create a textarea field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ * @param field
+ */
+export function textAreaField(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: 'textarea',
+        build() {
+            // Use the original field config directly (it doesn't have build() method)
+            return new TextAreaField(field);
+        },
+    };
+    return config;
+}

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

@@ -0,0 +1,148 @@
+import type { BaseFieldConfig } from './field';
+import { entityKind } from '../helpers';
+import { FileField } from './fileField';
+import * as z from 'zod';
+declare const configSchema: z.ZodObject<{
+    /**
+     * Maximum file size
+     */
+    maxFileSize: z.ZodOptional<z.ZodObject<{
+        size: z.ZodNumber;
+        unit: z.ZodEnum<{
+            kb: "kb";
+            mb: "mb";
+        }>;
+    }, z.core.$strict>>;
+    /**
+     * Allowed file types
+     * @default ['mp4']
+     */
+    type: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        mp4: "mp4";
+        webm: "webm";
+        ogg: "ogg";
+    }>>>;
+}, z.core.$strict>;
+type Config = z.infer<typeof configSchema>;
+export declare class VideoField extends FileField<'video', Config> {
+    static readonly [entityKind]: string;
+    readonly maxFileSize: {
+        size: number;
+        unit: 'kb' | 'mb';
+    };
+    readonly mimeType: string[];
+    readonly extensions: string[];
+    /**
+     * _file is the file object if it's present
+     * Whereas the value is the path to the file
+     */
+    private _file;
+    private _buffer;
+    private _folder;
+    private _allowedExtensions;
+    readonly uploadsFolder: string;
+    constructor(config: BaseFieldConfig<Config>, file?: File);
+    exportForClient(): {
+        maxFileSize: {
+            size: number;
+            unit: "kb" | "mb";
+        };
+        extensions: string[];
+        mimeType: string[];
+        type: "video";
+        name: string;
+        label: string;
+        required: boolean;
+        conditionalFields: import("../types").ConditionalField[];
+        readonly: boolean;
+        defaultValue: any;
+        value: any;
+    };
+    readChunkFromFile({ arrayBuffer, length, startPosition, }: {
+        readonly arrayBuffer: ArrayBuffer;
+        readonly length: number;
+        readonly startPosition?: number;
+    }): Promise<Uint8Array>;
+    /**
+     * Write the file to the disk
+     */
+    writeToFile(): Promise<void>;
+    postSubmit(folder: string): Promise<void>;
+    postSubmitRollback(): Promise<void>;
+    /**
+     * Get the value of the field
+     */
+    getValue(): string;
+    setFileName(value: string): void;
+    setValue(value: any): void;
+    setFile(file: File): void;
+    checkRequired(): void;
+    /**
+     * Prepare the field for submission
+     */
+    prepareForSubmission(): Promise<void>;
+}
+export type VideoFieldClientConfig = ReturnType<VideoField['exportForClient']>;
+declare const optionsSchema: z.ZodObject<{
+    /**
+     * Maximum file size
+     */
+    maxFileSize: z.ZodOptional<z.ZodObject<{
+        size: z.ZodNumber;
+        unit: z.ZodEnum<{
+            kb: "kb";
+            mb: "mb";
+        }>;
+    }, z.core.$strict>>;
+    /**
+     * Allowed file types
+     * @default ['mp4']
+     */
+    type: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        mp4: "mp4";
+        webm: "webm";
+        ogg: "ogg";
+    }>>>;
+    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").ConditionalRule, import("../types").ConditionalRule>>>;
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>;
+declare const videoFieldConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"video">;
+    build: z.ZodFunction<z.core.$ZodFunctionArgs, z.ZodCustom<VideoField, VideoField>>;
+    /**
+     * Maximum file size
+     */
+    maxFileSize: z.ZodOptional<z.ZodObject<{
+        size: z.ZodNumber;
+        unit: z.ZodEnum<{
+            kb: "kb";
+            mb: "mb";
+        }>;
+    }, 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").ConditionalRule, import("../types").ConditionalRule>>>;
+    adminGenerated: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodLiteral<false>, z.ZodLiteral<"readonly">]>>;
+}, z.core.$strict>;
+/**
+ * Video field configuration type
+ * This is a plain object that can be serialized and used anywhere
+ * The build() method allows creating a VideoField instance when needed
+ */
+export type VideoFieldConfig = z.infer<typeof videoFieldConfigSchema>;
+/**
+ * Helper function to create a video field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ * @param field
+ */
+export declare function videoField(field: z.infer<typeof optionsSchema>): VideoFieldConfig;
+export {};
+//# sourceMappingURL=video.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"video.d.ts","sourceRoot":"","sources":["../../../src/core/fields/video.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE9C,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAIvC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEvC,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAExB,QAAA,MAAM,YAAY;IACd;;OAEG;;;;;;;;IAQH;;;OAGG;;;;;;kBAKL,CAAA;AAEF,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAE1C,qBAAa,UAAW,SAAQ,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IACtD,gBAAyB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAe;IAC5D,QAAQ,CAAC,WAAW,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAAA;KAAE,CAAA;IACzD,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,CAAA;IAE7B;;;OAGG;IACH,OAAO,CAAC,KAAK,CAAkB;IAC/B,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,kBAAkB,CAAU;IACpC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAyC;gBAC3D,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,IAAI;IA6BxC,eAAe;;kBA1CD,MAAM;kBAAQ,IAAI,GAAG,IAAI;;;;;;;;;;;;;IAmDjD,iBAAiB,CAAC,EACpB,WAAW,EACX,MAAM,EACN,aAAiB,GACpB,EAAE;QACC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;QACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;QACvB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAClC,GAAG,OAAO,CAAC,UAAU,CAAC;IAevB;;OAEG;IACG,WAAW;IAiCK,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKzC,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAczD;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIX,WAAW,CAAC,KAAK,EAAE,MAAM;IAIvB,QAAQ,CAAC,KAAK,EAAE,GAAG;IAQnB,OAAO,CAAC,IAAI,EAAE,IAAI;IAK3B,aAAa;IAYb;;OAEG;IACG,oBAAoB;CAoD7B;AAED,MAAM,MAAM,sBAAsB,GAAG,UAAU,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAA;AAE9E,QAAA,MAAM,aAAa;IAxPf;;OAEG;;;;;;;;IAQH;;;OAGG;;;;;;;;;;;;;kBA8OL,CAAA;AAEF,QAAA,MAAM,sBAAsB;;;IA7PxB;;OAEG;;;;;;;;;;;;;;;kBA+PL,CAAA;AAEF;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,GAAG,gBAAgB,CAmBjF"}

package/dist/core/fields/video.js

@@ -0,0 +1,248 @@
+import { baseFieldConfigSchema } from './field';
+import { entityKind } from '../helpers';
+import fs from 'fs';
+import { customAlphabet } from 'nanoid';
+import path from 'path';
+import { FileField } from './fileField';
+import { getCMSConfig } from '../config';
+import * as z from 'zod';
+const configSchema = z.strictObject({
+    /**
+     * Maximum file size
+     */
+    maxFileSize: z
+        .strictObject({
+        size: z.number().describe('The size value'),
+        unit: z.enum(['kb', 'mb']).describe('The unit of the size'),
+    })
+        .optional()
+        .describe('Maximum file size'),
+    /**
+     * Allowed file types
+     * @default ['mp4']
+     */
+    type: z
+        .array(z.enum(['mp4', 'webm', 'ogg']))
+        .optional()
+        .describe('Allowed file types'),
+});
+export class VideoField extends FileField {
+    static [entityKind] = 'VideoField';
+    maxFileSize;
+    mimeType;
+    extensions;
+    /**
+     * _file is the file object if it's present
+     * Whereas the value is the path to the file
+     */
+    _file;
+    _buffer;
+    _folder;
+    _allowedExtensions;
+    uploadsFolder = getCMSConfig().files.upload.uploadPath;
+    constructor(config, file) {
+        super(config, 'video');
+        this._file = file;
+        this.extensions = config.type ?? ['mp4'];
+        this.maxFileSize = config.maxFileSize ?? { size: 2, unit: 'mb' };
+        /**
+         * Extract the mime types from the extensions
+         * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
+         */
+        this.mimeType = this.extensions.map((e) => {
+            switch (e) {
+                case 'mp4':
+                    return 'video/mp4';
+                case 'webm':
+                    return 'video/webm';
+                case 'ogg':
+                    return 'video/ogg';
+                default:
+                    return '';
+            }
+        });
+        /**
+         * Set the allowed extensions, add jpg if jpeg is present
+         */
+        this._allowedExtensions = this.extensions;
+    }
+    exportForClient() {
+        return {
+            ...super.exportForClient(),
+            maxFileSize: this.maxFileSize,
+            extensions: this._allowedExtensions,
+            mimeType: this.mimeType,
+        };
+    }
+    async readChunkFromFile({ arrayBuffer, length, startPosition = 0, }) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                if (arrayBuffer) {
+                    const buffer = new Uint8Array(arrayBuffer, startPosition, length);
+                    resolve(buffer);
+                }
+                else {
+                    reject(new Error('Error reading file'));
+                }
+            }
+            catch (error) {
+                reject(new Error('Error reading file'));
+            }
+        });
+    }
+    /**
+     * Write the file to the disk
+     */
+    async writeToFile() {
+        if (!this._folder) {
+            throw new Error(`${this.label}: Folder is not set. Make sure to set the folder by call postSubmit() before writing the file to disk`);
+        }
+        if (!this._buffer) {
+            throw new Error(`${this.label}: Buffer is not set. Make sure to call prepareForSubmission() before writing the file to disk`);
+        }
+        try {
+            /**
+             * If .videos, and 'sectionName' folders don't exist, create them
+             */
+            const vdieosFolder = path.join(this.uploadsFolder, '.videos', this._folder);
+            if (!fs.existsSync(vdieosFolder)) {
+                fs.mkdirSync(vdieosFolder, { recursive: true });
+            }
+            /**
+             * Write the file to disk
+             */
+            await fs.promises.writeFile(path.join(this.uploadsFolder, '.videos', this._folder, this.value), this._buffer);
+        }
+        catch (error) {
+            throw new Error(`${this.label}: Error writing file to disk ${error.message}`);
+        }
+    }
+    async postSubmit(folder) {
+        this._folder = folder;
+        await this.writeToFile();
+    }
+    async postSubmitRollback() {
+        if (!this._folder) {
+            throw new Error(`${this.label}: Folder is not set. Make sure to set the folder before writing the file to disk`);
+        }
+        try {
+            const pathToFile = path.join(this.uploadsFolder, '.videos', this._folder, this.value);
+            await fs.promises.unlink(pathToFile);
+        }
+        catch (error) {
+            throw new Error(`${this.label}: Error deleting file from disk`);
+        }
+    }
+    /**
+     * Get the value of the field
+     */
+    getValue() {
+        return this.value;
+    }
+    setFileName(value) {
+        this.value = value;
+    }
+    setValue(value) {
+        if (typeof value === 'string') {
+            this.setFileName(value);
+            return;
+        }
+        this.setFile(value);
+    }
+    setFile(file) {
+        if (!file || file.size === 0 || file.name?.trim() === '')
+            return;
+        this._file = file;
+    }
+    checkRequired() {
+        /**
+         * Check if the field is required
+         * If it is, check if the file is present
+         * If it's not, throw an error
+         * Note: Those values are coming from the browser (not safe)
+         */
+        if ((this.required && !this._file) || !this._file?.type || !this._file?.name || !this._file?.size) {
+            throw new Error(`Field ${this.label} is required`);
+        }
+    }
+    /**
+     * Prepare the field for submission
+     */
+    async prepareForSubmission() {
+        if (!this._file)
+            return;
+        /**
+         * Check the actual file size
+         */
+        const arrayBuffer = await this._file.arrayBuffer();
+        this._buffer = Buffer.from(arrayBuffer);
+        if (!this._buffer.length) {
+            throw new Error(`Field ${this.label} is required`);
+        }
+        /**
+         * Check extension
+         */
+        const ext = this._file.name.split('.').pop();
+        if (!ext || !this.extensions.includes(ext)) {
+            throw new Error(`${this.label}: Invalid file type or extension. Allowed extensions: ${this.extensions.join(', ')}`);
+        }
+        /**
+         * Read the first 4100 bytes of the file
+         */
+        const chunkBuffer = await this.readChunkFromFile({ arrayBuffer, length: 4100 });
+        /**
+         * Get the file type from the buffer
+         */
+        const { fileTypeFromBuffer } = await import('file-type');
+        const fileType = await fileTypeFromBuffer(chunkBuffer);
+        /**
+         * If the file type is invalid, return an error
+         */
+        if (!fileType) {
+            throw new Error(`${this.label}: Invalid file type`);
+        }
+        /**
+         * Don't just trust the file extension
+         * Check the `fileType.ext` against the allowed extensions
+         */
+        if (!fileType.ext || !this.extensions.includes(fileType.ext)) {
+            throw new Error(`${this.label}: Invalid file type or extension. Allowed extensions: ${this.extensions.join(', ')}`);
+        }
+        /**
+         * Generate a random name for the file
+         */
+        this.value = customAlphabet('1234567890abcdef', 21)();
+    }
+}
+const optionsSchema = z.strictObject({
+    ...baseFieldConfigSchema.shape,
+    ...configSchema.shape,
+});
+const videoFieldConfigSchema = z.strictObject({
+    ...optionsSchema.shape,
+    type: z.literal('video').describe('The type of the field'),
+    build: z.function().output(z.instanceof(VideoField)).describe('Build a VideoField instance from this config'),
+});
+/**
+ * Helper function to create a video field configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ * @param field
+ */
+export function videoField(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: 'video',
+        build() {
+            // Use the original field config directly (it doesn't have build() method)
+            return new VideoField(field);
+        },
+    };
+    return config;
+}

package/dist/core/helpers/entity.d.ts

@@ -0,0 +1,8 @@
+export declare const entityKind: unique symbol;
+export declare const hasOwnEntityKind: unique symbol;
+export interface LZEntity {
+    [entityKind]: string;
+}
+export type LZEntityClass<T> = ((abstract new (...args: any[]) => T) | (new (...args: any[]) => T)) & LZEntity;
+export declare function is<T extends LZEntityClass<any>>(value: any, type: T): value is InstanceType<T>;
+//# sourceMappingURL=entity.d.ts.map

package/dist/core/helpers/entity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../../src/core/helpers/entity.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,eAA8B,CAAA;AACrD,eAAO,MAAM,gBAAgB,eAAoC,CAAA;AAEjE,MAAM,WAAW,QAAQ;IACrB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,GAAG,CAAC,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAA;AAE9G,wBAAgB,EAAE,CAAC,CAAC,SAAS,aAAa,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,GAAG,KAAK,IAAI,YAAY,CAAC,CAAC,CAAC,CAiC9F"}

package/dist/core/helpers/entity.js

@@ -0,0 +1,27 @@
+export const entityKind = Symbol.for('lz:entityKind');
+export const hasOwnEntityKind = Symbol.for('lz:hasOwnEntityKind');
+export function is(value, type) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    if (value instanceof type) {
+        return true;
+    }
+    if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
+        throw new Error(`Class "${type.name ?? '<unknown>'}" doesn't look like a LZ entity. If this is incorrect and the class is provided by LZ, please report this as a bug.`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
+    let cls = value.constructor;
+    if (cls) {
+        // Traverse the prototype chain to find the entityKind
+        while (cls) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            if (entityKind in cls && cls[entityKind] === type[entityKind]) {
+                return true;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            cls = Object.getPrototypeOf(cls);
+        }
+    }
+    return false;
+}

package/dist/core/helpers/index.d.ts

@@ -0,0 +1,5 @@
+export { is } from './entity';
+export { entityKind } from './entity';
+export type { LZEntity } from './entity';
+export { hasOwnEntityKind } from './entity';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/helpers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/helpers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,UAAU,CAAA;AAC7B,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AACrC,YAAY,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA"}

package/dist/core/helpers/index.js

@@ -0,0 +1,3 @@
+export { is } from './entity';
+export { entityKind } from './entity';
+export { hasOwnEntityKind } from './entity';

package/dist/core/index.d.ts

@@ -0,0 +1,8 @@
+export * from './config';
+export * from './factories';
+export * from './fields';
+export * from './sections';
+export * from './submit';
+export * from './db';
+export * from './helpers';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA;AAC3B,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA;AAC1B,cAAc,UAAU,CAAA;AACxB,cAAc,MAAM,CAAA;AACpB,cAAc,WAAW,CAAA"}

package/dist/core/index.js

@@ -0,0 +1,7 @@
+export * from './config';
+export * from './factories';
+export * from './fields';
+export * from './sections';
+export * from './submit';
+export * from './db';
+export * from './helpers';