nextjs-cms 0.0.1 → 0.5.1

package/dist/core/factories/FieldFactory.d.ts

@@ -0,0 +1,124 @@
+import type { Section } from '../sections';
+import type { Session } from '../../auth';
+type ConstructorType = {
+    type: 'new';
+    sectionName: string;
+    session: Session;
+    itemId?: never;
+} | {
+    type: 'edit';
+    sectionName: string;
+    session: Session;
+    itemId: number | string;
+};
+export declare class FieldFactory {
+    private readonly session;
+    private _values;
+    private itemId;
+    private _error;
+    private _errorMessage;
+    protected type: 'new' | 'edit';
+    protected sectionName: string;
+    private _sectionInfo;
+    /**
+     * Default order value for items without explicit order.
+     * Ensures items without order come after explicitly ordered items.
+     * Typical order values: 0-15, with occasional values up to 1000.
+     */
+    private static readonly DEFAULT_ORDER;
+    /**
+     * Constructor
+     */
+    constructor({ type, sectionName, session, itemId }: ConstructorType);
+    /**
+     * Must be called after the constructor
+     */
+    initialize(): Promise<void>;
+    private getFieldValue;
+    private initializeFieldValues;
+    /**
+     * Gets the section info and assigns it to the `sectionInfo` property
+     * @param session
+     * @private
+     */
+    private initializeSectionInfo;
+    /**
+     * Get the section info from the `sectionsTable` table
+     * @param session
+     * @private
+     */
+    private getSectionInfo;
+    /**
+     * Prepare a field for use
+     * Fields are already instances (resolved in Section constructor), so we just need to set values
+     * @param field
+     */
+    private prepareField;
+    private addPermissionField;
+    /**
+     * Generate the fields
+     */
+    generateFields(): Promise<void>;
+    /**
+     * Sort the fields.
+     * This function sorts the conditional fields into their respective fields.
+     */
+    private sortFields;
+    /**
+     * Sort fields by their order property, preserving original position for fields without order.
+     *
+     * Sorting behavior:
+     * 1. Fields with explicit `order` values are sorted by that value (ascending)
+     * 2. Fields without `order` maintain their original array position (stable sort)
+     * 3. Fields with the same `order` value maintain their relative positions (stable sort)
+     *
+     * This leverages JavaScript's stable Array.sort() (ES2019+) for optimal performance.
+     * Note: This mutates the input array for performance.
+     *
+     * @param fields - Array of fields to sort (will be mutated)
+     * @returns The sorted array (same reference as input)
+     * @private
+     */
+    private sortFieldsByOrder;
+    /**
+     * Sort groups by their groupOrder property, preserving original position for groups without order.
+     *
+     * Sorting behavior:
+     * 1. Groups with explicit `groupOrder` values are sorted by that value (ascending)
+     * 2. Groups without `groupOrder` maintain their original array position (stable sort)
+     * 3. Groups with the same `groupOrder` value maintain their relative positions (stable sort)
+     *
+     * This leverages JavaScript's stable Array.sort() (ES2019+) for optimal performance.
+     * Note: This mutates the input array for performance.
+     * Note: groupOrder is normalized at creation time, so no nullish coalescing needed here.
+     *
+     * @param groups - Array of groups to sort (will be mutated)
+     * @returns The sorted array (same reference as input)
+     * @private
+     */
+    private sortGroupsByOrder;
+    /**
+     * Get field groups with filtered and sorted fields.
+     * Leverages the pre-built fieldGroups from the Section class for better performance.
+     */
+    getGroupedFields(): {
+        groupId: number;
+        groupTitle: string;
+        groupOrder: number;
+        inputs: {
+            type: import("../types").FieldType;
+            name: string;
+            label: string;
+            required: boolean;
+            conditionalFields: import("../types").ConditionalField[];
+            readonly: boolean;
+            defaultValue: any;
+            value: any;
+        }[];
+    }[] | undefined;
+    get sectionInfo(): Section | undefined;
+    get errorMessage(): string;
+    get error(): boolean;
+}
+export {};
+//# sourceMappingURL=FieldFactory.d.ts.map

package/dist/core/factories/FieldFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FieldFactory.d.ts","sourceRoot":"","sources":["../../../src/core/factories/FieldFactory.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAG1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAIzC,KAAK,eAAe,GACd;IACI,IAAI,EAAE,KAAK,CAAA;IACX,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,CAAC,EAAE,KAAK,CAAA;CACjB,GACD;IACI,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;CAC1B,CAAA;AAEP,qBAAa,YAAY;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,MAAM,CAAyC;IACvD,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,aAAa,CAAa;IAClC,SAAS,CAAC,IAAI,EAAE,KAAK,GAAG,MAAM,CAAA;IAC9B,SAAS,CAAC,WAAW,EAAE,MAAM,CAAA;IAC7B,OAAO,CAAC,YAAY,CAA4B;IAGhD;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAAY;IAEjD;;OAEG;gBACS,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,eAAe;IASnE;;OAEG;IACU,UAAU;YAUT,aAAa;YASb,qBAAqB;IAkEnC;;;;OAIG;YACW,qBAAqB;IAuCnC;;;;OAIG;YACW,cAAc;IAuB5B;;;;OAIG;YACW,YAAY;IAgB1B,OAAO,CAAC,kBAAkB;IAa1B;;OAEG;IACU,cAAc;IAqB3B;;;OAGG;IACH,OAAO,CAAC,UAAU;IA4ElB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,iBAAiB;IAMzB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,iBAAiB;IAOzB;;;OAGG;IACI,gBAAgB;;;;;;;;;;;;;;;IAmEvB,IAAI,WAAW,IAAI,OAAO,GAAG,SAAS,CAErC;IACD,IAAI,YAAY,IAAI,MAAM,CAEzB;IACD,IAAI,KAAK,IAAI,OAAO,CAEnB;CACJ"}

package/dist/core/factories/FieldFactory.js

@@ -0,0 +1,411 @@
+import { sql } from 'drizzle-orm';
+import { db } from '../../db/client';
+import { SectionFactory } from './SectionFactory';
+import { SimpleSection, HasItemsSection, CategorySection } from '../sections';
+import { checkboxField, SelectField, SelectMultipleField } from '../fields';
+import { is } from '../helpers';
+import { cloneDeep } from 'lodash-es';
+import chalk from 'chalk';
+export class FieldFactory {
+    session;
+    _values = {};
+    itemId = undefined;
+    _error = false;
+    _errorMessage = '';
+    type;
+    sectionName;
+    _sectionInfo;
+    // private _fields: Field[]
+    /**
+     * Default order value for items without explicit order.
+     * Ensures items without order come after explicitly ordered items.
+     * Typical order values: 0-15, with occasional values up to 1000.
+     */
+    static DEFAULT_ORDER = 1_000_000;
+    /**
+     * Constructor
+     */
+    constructor({ type, sectionName, session, itemId }) {
+        this.type = type;
+        this.sectionName = sectionName;
+        this.session = session;
+        this.itemId = itemId;
+        // this._fields = new Array<Field>()
+        this._sectionInfo = undefined;
+    }
+    /**
+     * Must be called after the constructor
+     */
+    async initialize() {
+        await this.initializeSectionInfo(this.session);
+        /**
+         * If it's an edit operation, let's initialize the field values
+         */
+        if (this.type === 'edit') {
+            await this.initializeFieldValues();
+        }
+    }
+    async getFieldValue(field) {
+        if (this.type === 'new')
+            return undefined;
+        try {
+            return this._values[field.name];
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    async initializeFieldValues() {
+        if (this._error)
+            return;
+        if (this._sectionInfo?.db.table && this._sectionInfo.db.identifier) {
+            /**
+             * Let's get the section item values from its table and assign it to the `_values` property
+             */
+            // TODO: We still need to get the values from the `destinationDbTable` if it exists on any field
+            //  also, select_multiple fields need to be handled the same way, plus value is array of strings
+            const [_v, fields] = await db.execute(sql `select * from ${sql.raw(this._sectionInfo.db.table)} where ${sql.raw(this._sectionInfo.db.identifier.name)} = ${this.itemId} limit 1`);
+            // @ts-ignore
+            // Bug: this is a bug in drizzle-orm/mysql2
+            this._values = _v[0];
+            /**
+             * If the field has a destinationDb
+             * Get the result from the field's table and the destinationDb's table using a JOIN query
+             * Fields that can have a destinationDb are: SelectField, SelectMultipleField, TagsField
+             */
+            for (const field of this._sectionInfo.fields) {
+                if (field.destinationDb && (is(field, SelectMultipleField) || is(field, SelectField))) {
+                    const sqlChunks = [
+                        sql `select * from ${sql.raw(field.destinationDb.table)} a JOIN ${sql.raw(field.db.table)} b ON a.${sql.raw(field.destinationDb.selectIdentifier)} = b.${sql.raw(field.db.identifier)} where ${sql.raw(field.destinationDb.itemIdentifier)} = ${this.itemId}`,
+                    ];
+                    if (is(field, SelectField) && field.hasDepth()) {
+                        /**
+                         * Add the where clause to the select statement
+                         */
+                        sqlChunks.push(sql ` ORDER BY b.level ASC`);
+                    }
+                    const [_rows, _fields] = await db.execute(sql.join(sqlChunks));
+                    const values = [];
+                    if (Array.isArray(_rows)) {
+                        for (const row of _rows) {
+                            values.push({
+                                value: row[field.destinationDb.selectIdentifier],
+                                label: row[field.db.label],
+                            });
+                        }
+                    }
+                    this._values[field.name] = values;
+                }
+            }
+            /**
+             * If the section item is not found, set the `_error` property to true
+             */
+            if (!is(this._sectionInfo, SimpleSection) && !this._values) {
+                this._error = true;
+                this._errorMessage = 'Item not found';
+                return;
+            }
+        }
+        else {
+            this._error = true;
+            this._errorMessage = 'Section table or section table identifier is missing';
+            return;
+        }
+    }
+    /**
+     * Gets the section info and assigns it to the `sectionInfo` property
+     * @param session
+     * @private
+     */
+    async initializeSectionInfo(session) {
+        /**
+         * Get section info - could be a config (with build()) or an instance
+         * Section files should export configs, but we handle both for backward compatibility
+         */
+        let _s = await this.getSectionInfo(session);
+        if (_s === undefined)
+            return;
+        /**
+         * Build the section from config when we need to use it
+         * SectionFactory returns configs, so we always build them here
+         *
+         * Double check if the config has a build() method
+         */
+        if (typeof _s.build === 'function') {
+            // It's a config - build it to get a fresh instance
+            // We build here because we immediately need to access section properties (db.table, inputs, etc.)
+            this._sectionInfo = _s.build();
+            /**
+             * Build the fields from the field configs
+             */
+            this._sectionInfo.buildFields();
+        }
+        else {
+            const errorMessage = 'Section config must have a build() method. Use helper functions like simpleSection(), hasItemsSection(), categorySection() to create section configs.';
+            console.error(chalk.bold.red('[FieldFactory Error]', errorMessage));
+            this._error = true;
+            this._errorMessage = errorMessage;
+            throw new Error(errorMessage);
+        }
+        /**
+         * Unset the `_s` variable to be garbage collected
+         */
+        _s = undefined;
+    }
+    /**
+     * Get the section info from the `sectionsTable` table
+     * @param session
+     * @private
+     */
+    async getSectionInfo(session) {
+        /**
+         * First, let's get the section details, and then get the section input fields
+         */
+        const s = await SectionFactory.getSectionForAdmin({
+            name: this.sectionName,
+            admin: {
+                id: session.user.id,
+                requiredRole: this.type === 'new' ? 'C' : 'U',
+            },
+        });
+        if (!s || !s.name) {
+            this._error = true;
+            this._errorMessage = 'Section not found or you do not have access to this operation';
+            return undefined;
+        }
+        return s;
+    }
+    /**
+     * Prepare a field for use
+     * Fields are already instances (resolved in Section constructor), so we just need to set values
+     * @param field
+     */
+    async prepareField(field) {
+        // Fields are already instances - no need to build them
+        // They were resolved from configs in the Section constructor
+        if (this.type === 'edit') {
+            /**
+             * If it's an edit operation, get the value from the database and set it
+             */
+            const value = await this.getFieldValue(field);
+            // It's important to set the value to whatever is in the database,
+            // even if the field has a `defaultValue` set.
+            field.setValue(value);
+        }
+    }
+    // TODO: Implement this, maybe set the roles in the trpc context?
+    addPermissionField() {
+        if (is(this._sectionInfo, HasItemsSection)) {
+            if (this._sectionInfo.requirePublishPermission && this.session.user) {
+                return checkboxField({
+                    name: 'publish',
+                    label: 'Publish',
+                    required: true,
+                    order: 1000,
+                });
+            }
+        }
+    }
+    /**
+     * Generate the fields
+     */
+    async generateFields() {
+        if (this._error)
+            return;
+        if (!this._sectionInfo)
+            return;
+        for (const input of this._sectionInfo.fields) {
+            /**
+             * If it's an edit operation, set the field to readonly if it's the identifier field,
+             * identifier fields must not be edited!
+             * They are always visible as a readonly text.
+             */
+            if (this.type === 'edit' && input.name === this._sectionInfo.db.identifier.name) {
+                input.adminGenerated = 'readonly';
+            }
+            /**
+             * Prepare the field (set values if editing)
+             */
+            await this.prepareField(input);
+        }
+        this.sortFields();
+    }
+    /**
+     * Sort the fields.
+     * This function sorts the conditional fields into their respective fields.
+     */
+    sortFields() {
+        if (this._error)
+            return;
+        if (!this._sectionInfo)
+            return;
+        /**
+         * Create a map of conditional fields
+         */
+        const _conditionalFieldMap = new Map();
+        /**
+         * Loop through the fields and get the conditional fields
+         */
+        for (const input of this._sectionInfo.fields) {
+            input.conditionalFields = [];
+            /**
+             * Check if the field is conditional.
+             */
+            if (input.isConditional()) {
+                for (const rule of input.conditionalRules ?? []) {
+                    /**
+                     * Add the conditional input to the conditional fields lists
+                     */
+                    if (!_conditionalFieldMap.has(rule.field.name)) {
+                        _conditionalFieldMap.set(rule.field.name, []);
+                    }
+                    _conditionalFieldMap.get(rule.field.name).push(
+                    /**
+                     * Clone the conditional field to avoid reference issues
+                     */
+                    cloneDeep({
+                        field: input.exportForClient(),
+                        rule: {
+                            condition: rule.condition,
+                            value: rule.value,
+                        },
+                    }));
+                }
+            }
+        }
+        /**
+         * Assign conditionalFields to the appropriate fields
+         */
+        for (const field of this._sectionInfo.fields) {
+            const matchingConditionalFields = _conditionalFieldMap.get(field.name);
+            if (matchingConditionalFields) {
+                field.conditionalFields.push(...matchingConditionalFields.map((clonedConditionalField) => ({
+                    ...clonedConditionalField,
+                    rule: {
+                        condition: clonedConditionalField.rule.condition,
+                        value: clonedConditionalField.rule.value,
+                    },
+                })));
+            }
+        }
+        /**
+         * Destroy the map
+         */
+        _conditionalFieldMap.clear();
+    }
+    /**
+     * Sort fields by their order property, preserving original position for fields without order.
+     *
+     * Sorting behavior:
+     * 1. Fields with explicit `order` values are sorted by that value (ascending)
+     * 2. Fields without `order` maintain their original array position (stable sort)
+     * 3. Fields with the same `order` value maintain their relative positions (stable sort)
+     *
+     * This leverages JavaScript's stable Array.sort() (ES2019+) for optimal performance.
+     * Note: This mutates the input array for performance.
+     *
+     * @param fields - Array of fields to sort (will be mutated)
+     * @returns The sorted array (same reference as input)
+     * @private
+     */
+    sortFieldsByOrder(fields) {
+        // Sort in-place for performance (mutates array)
+        // JavaScript's sort is stable (ES2019+), so equal values maintain original order
+        return fields.sort((a, b) => (a.order ?? FieldFactory.DEFAULT_ORDER) - (b.order ?? FieldFactory.DEFAULT_ORDER));
+    }
+    /**
+     * Sort groups by their groupOrder property, preserving original position for groups without order.
+     *
+     * Sorting behavior:
+     * 1. Groups with explicit `groupOrder` values are sorted by that value (ascending)
+     * 2. Groups without `groupOrder` maintain their original array position (stable sort)
+     * 3. Groups with the same `groupOrder` value maintain their relative positions (stable sort)
+     *
+     * This leverages JavaScript's stable Array.sort() (ES2019+) for optimal performance.
+     * Note: This mutates the input array for performance.
+     * Note: groupOrder is normalized at creation time, so no nullish coalescing needed here.
+     *
+     * @param groups - Array of groups to sort (will be mutated)
+     * @returns The sorted array (same reference as input)
+     * @private
+     */
+    sortGroupsByOrder(groups) {
+        // Sort in-place for performance (mutates array)
+        // JavaScript's sort is stable (ES2019+), so equal values maintain original order
+        // groupOrder is normalized at creation time, so direct subtraction is safe
+        return groups.sort((a, b) => a.groupOrder - b.groupOrder);
+    }
+    /**
+     * Get field groups with filtered and sorted fields.
+     * Leverages the pre-built fieldGroups from the Section class for better performance.
+     */
+    getGroupedFields() {
+        if (this._error)
+            return;
+        if (!this._sectionInfo)
+            return;
+        const fieldGroups = this._sectionInfo.fieldGroups;
+        const isNewOperation = this.type === 'new';
+        const isEditOperation = this.type === 'edit';
+        const isCategorySection = is(this._sectionInfo, CategorySection);
+        // Build groups in a single pass, skipping empty groups
+        const processedGroups = [];
+        for (let i = 0, len = fieldGroups.length; i < len; i++) {
+            const group = fieldGroups[i];
+            if (!group)
+                continue;
+            const fields = group.fields;
+            const validFields = [];
+            // Filter and collect valid fields in one pass
+            for (let j = 0, fieldLen = fields.length; j < fieldLen; j++) {
+                const field = fields[j];
+                if (!field)
+                    continue;
+                // Skip conditional fields (they're nested in their parent field)
+                if (field.isConditional())
+                    continue;
+                // For new item operations, exclude fields with adminGenerated not set to true
+                if (isNewOperation && field.adminGenerated !== true)
+                    continue;
+                // For edit operations, exclude fields with adminGenerated set to false
+                if (isEditOperation && field.adminGenerated === false)
+                    continue;
+                // For category sections, exclude parent_id and level fields
+                if (isCategorySection && (field.name === 'parent_id' || field.name === 'level'))
+                    continue;
+                /**
+                 * Add the field to the valid fields array
+                 */
+                validFields.push(field);
+            }
+            /**
+             * Only return the group if it has valid fields
+             */
+            if (validFields.length > 0) {
+                processedGroups.push({
+                    groupId: group.id,
+                    groupTitle: group.title ?? '',
+                    // Normalize order value here to avoid checking again in sort function
+                    groupOrder: group.order ?? FieldFactory.DEFAULT_ORDER,
+                    inputs: this.sortFieldsByOrder(validFields).map((field) => field.exportForClient()),
+                });
+            }
+        }
+        // Sort groups by order using the optimized function
+        this.sortGroupsByOrder(processedGroups);
+        /**
+         * Unset the section info to be garbage collected
+         */
+        this._sectionInfo = null;
+        return processedGroups;
+    }
+    get sectionInfo() {
+        return this._sectionInfo ?? undefined;
+    }
+    get errorMessage() {
+        return this._errorMessage;
+    }
+    get error() {
+        return this._error;
+    }
+}

package/dist/core/factories/SectionFactory.d.ts

@@ -0,0 +1,110 @@
+import { HasItemsSection, SimpleSection, CategorySection } from '../sections';
+import type { CategorySectionConfig, HasItemsSectionConfig, SimpleSectionConfig } from '../sections';
+import type { SectionTypes } from '../types';
+type AnySectionConfig = HasItemsSectionConfig | SimpleSectionConfig | CategorySectionConfig;
+export declare class SectionFactory {
+    /**
+     * These are the fixed sections that can not be present in the sections folder.
+     */
+    static readonly fixedSections: string[];
+    private static readonly isDev;
+    private static readonly isProd;
+    private static sectionProcessingErrors;
+    private static sectionFetchingErrors;
+    private static errorCount;
+    /**
+     * Global in-process cache for all section configs.
+     * Populated once per Node process via loadAllSections(),
+     * reused by all get*() calls until the process is restarted,
+     * so all subsequent calls reuse this array.
+     */
+    private static allSectionsPromise;
+    private static allSectionsLoaded;
+    private static watcherStarted;
+    static bumpHotMarker(): void;
+    /**
+     * Get all sections
+     * @param type - The type of sections to get
+     * @returns The sections
+     */
+    static getSections(type?: SectionTypes | SectionTypes[]): Promise<AnySectionConfig[]>;
+    /**
+     * Get all accessible sections for an admin
+     * @param type - The type of section to get
+     * @param admin - The admin to get the sections for
+     * @returns The sections for the admin
+     */
+    static getSectionsForAdmin({ type, admin, }: {
+        type?: SectionTypes | SectionTypes[];
+        admin: {
+            id: string;
+            requiredRole?: 'C' | 'U' | 'D';
+        };
+    }): Promise<{
+        simple: SimpleSectionConfig[];
+        has_items: HasItemsSectionConfig[];
+        category: CategorySectionConfig[];
+        fixed: string[];
+    }>;
+    /**
+     * Get a section
+     * @param name - The name of the section to get
+     * @param type - The type of section to get
+     * @returns The section
+     */
+    static getSection({ name, type, }: {
+        name: string;
+        type?: SectionTypes | SectionTypes[];
+    }): Promise<AnySectionConfig | null>;
+    /**
+     * Get an accessible section for an admin
+     * @param name - The name of the section to get
+     * @param type - The type of section to get
+     * @param admin - The admin to get the section for
+     * @returns The section for the admin
+     */
+    static getSectionForAdmin({ name, type, admin, }: {
+        name: string;
+        type?: SectionTypes | SectionTypes[];
+        admin: {
+            id: string;
+            requiredRole?: 'C' | 'U' | 'D';
+        };
+    }): Promise<AnySectionConfig | null>;
+    /**
+     * Create a Section instance from a section config
+     * The config must have a build() method (created via helper functions like simpleSection(), hasItemsSection(), etc.)
+     *
+     * Note: This factory only accepts configs. If you already have a Section instance,
+     * use it directly - don't pass it to this factory.
+     *
+     * @param config - A section config object with a build() method
+     * @returns A Section instance
+     * @throws Error if config doesn't have a build() method
+     */
+    static create(config: {
+        build: () => HasItemsSection | SimpleSection | CategorySection;
+        [key: string]: any;
+    }): HasItemsSection | SimpleSection | CategorySection;
+    /**
+     * Return a clone of the section(s) info to get a fresh copy of the section(s).
+     * Not cloning will cause the original section(s) (in *.section.ts file) to be modified!
+     * Each *.section.ts file must have exactly one default export (arrays are not allowed).
+
+     * @param name - The name of the section to get
+     * @param type - The type of section to get
+     * @param admin - The admin to get the section for
+     * @returns The section(s)
+     */
+    private static get;
+    /**
+     * Load all *.section.ts files once, require their default exports,
+     * and cache the resulting configs for the lifetime of the process
+     * (until invalidated in dev by file changes).
+     */
+    private static loadAllSections;
+    private static startWatcher;
+    private static init;
+}
+export {};
+//# sourceMappingURL=SectionFactory.d.ts.map

package/dist/core/factories/SectionFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SectionFactory.d.ts","sourceRoot":"","sources":["../../../src/core/factories/SectionFactory.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC7E,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AACpG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AA+C5C,KAAK,gBAAgB,GAAG,qBAAqB,GAAG,mBAAmB,GAAG,qBAAqB,CAAA;AAY3F,qBAAa,cAAc;IACvB;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,aAAa,WAAiD;IAE9E,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAwC;IACrE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAc;IAE5C,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAA+B;IACrE,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAA+B;IACnE,OAAO,CAAC,MAAM,CAAC,UAAU,CAAI;IAE7B;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAA2C;IAC5E,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAQ;IACxC,OAAO,CAAC,MAAM,CAAC,cAAc,CAAQ;IAErC,MAAM,CAAC,aAAa,IAAI,IAAI;IAwB5B;;;;OAIG;WACU,WAAW,CAAC,IAAI,CAAC,EAAE,YAAY,GAAG,YAAY,EAAE,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAI3F;;;;;OAKG;WACU,mBAAmB,CAAC,EAC7B,IAAI,EACJ,KAAK,GACR,EAAE;QACC,IAAI,CAAC,EAAE,YAAY,GAAG,YAAY,EAAE,CAAA;QACpC,KAAK,EAAE;YACH,EAAE,EAAE,MAAM,CAAA;YACV,YAAY,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;SACjC,CAAA;KACJ,GAAG,OAAO,CAAC;QACR,MAAM,EAAE,mBAAmB,EAAE,CAAA;QAC7B,SAAS,EAAE,qBAAqB,EAAE,CAAA;QAClC,QAAQ,EAAE,qBAAqB,EAAE,CAAA;QACjC,KAAK,EAAE,MAAM,EAAE,CAAA;KAClB,CAAC;IA+BF;;;;;OAKG;WACU,UAAU,CAAC,EACpB,IAAI,EACJ,IAAI,GACP,EAAE;QACC,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,CAAC,EAAE,YAAY,GAAG,YAAY,EAAE,CAAA;KACvC,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAKpC;;;;;;OAMG;WACU,kBAAkB,CAAC,EAC5B,IAAI,EACJ,IAAI,EACJ,KAAK,GACR,EAAE;QACC,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,CAAC,EAAE,YAAY,GAAG,YAAY,EAAE,CAAA;QACpC,KAAK,EAAE;YACH,EAAE,EAAE,MAAM,CAAA;YACV,YAAY,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAA;SACjC,CAAA;KACJ,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAKpC;;;;;;;;;;OAUG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE;QAClB,KAAK,EAAE,MAAM,eAAe,GAAG,aAAa,GAAG,eAAe,CAAA;QAC9D,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KACrB,GAAG,eAAe,GAAG,aAAa,GAAG,eAAe;IAYrD;;;;;;;;;OASG;mBACkB,GAAG;IA6FxB;;;;OAIG;mBACkB,eAAe;IAuHpC,OAAO,CAAC,MAAM,CAAC,YAAY;IA+D3B,OAAO,CAAC,MAAM,CAAC,IAAI;CAatB"}