@medyll/idae-data-tpl 0.1.0

package/README.md

@@ -0,0 +1,58 @@
+# create-svelte
+
+Everything you need to build a Svelte library, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/main/packages/create-svelte).
+
+Read more about creating a library [in the docs](https://kit.svelte.dev/docs/packaging).
+
+## Creating a project
+
+If you're seeing this, you've probably already done this step. Congrats!
+
+```bash
+# create a new project in the current directory
+npm create svelte@latest
+
+# create a new project in my-app
+npm create svelte@latest my-app
+```
+
+## Developing
+
+Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+
+```bash
+npm run dev
+
+# or start the server and open the app in a new browser tab
+npm run dev -- --open
+```
+
+Everything inside `src/lib` is part of your library, everything inside `src/routes` can be used as a showcase or preview app.
+
+## Building
+
+To build your library:
+
+```bash
+npm run package
+```
+
+To create a production version of your showcase app:
+
+```bash
+npm run build
+```
+
+You can preview the production build with `npm run preview`.
+
+> To deploy your app, you may need to install an [adapter](https://kit.svelte.dev/docs/adapters) for your target environment.
+
+## Publishing
+
+Go into the `package.json` and give your package the desired name through the `"name"` option. Also consider adding a `"license"` field and point it to a `LICENSE` file which you can create from a template (one popular option is the [MIT license](https://opensource.org/license/mit/)).
+
+To publish your library to [npm](https://www.npmjs.com):
+
+```bash
+npm publish
+```

package/dist/dataTemplate/dataTemplate.d.ts

@@ -0,0 +1,70 @@
+import type { TplCollectionName, IdaeTemplate, IDbForgeFields, IDbFieldRules, IDbForgeArgs, IDbFieldType, IdaeModelRoot, IdaeTemplateFields, ForgeFieldTypes, CoreModel } from './types.js';
+export declare const exampleModel: IdaeModelRoot;
+export declare class IdaeModelCore<T = Record<string, any>> {
+    #private;
+    model: IdaeModelRoot<T>;
+    constructor();
+    setModel<C = Record<string, any>>(model: IdaeModelRoot<C>): void;
+    addCollectionTemplate(collection: string, template: IdaeTemplate): void;
+    parseAllCollections(): Record<string, Record<string, any> | undefined>;
+    parseRawCollection(collection: TplCollectionName): Record<string, IDbForgeFields | undefined> | undefined;
+    parseCollectionFieldName(collection: TplCollectionName, fieldName: keyof IdaeTemplateFields<any>): IDbForgeFields<T> | undefined;
+    parsFieldRule(fieldRule: IDbFieldRules): Partial<IDbForgeFields<T>> | undefined;
+    private forge;
+    getCollection(collection: TplCollectionName): CoreModel;
+    getCollectionTemplate(collection: TplCollectionName): IdaeTemplate;
+    getCollectionTemplateFks(collection: TplCollectionName): IdaeTemplate["fks"];
+    getIndexName(collection: string): any;
+    getCollectionTemplateFields(collection: TplCollectionName): IdaeTemplateFields;
+    getTemplatePresentation(collection: TplCollectionName): string;
+    getFkFieldType(string: `${string}.${string}`): IDbFieldRules | undefined;
+    getFkTemplateFields(string: `${string}.${string}`): any;
+    private testIs;
+    is(what: ForgeFieldTypes, fieldRule: IDbFieldRules): Partial<IDbForgeFields>;
+    indexValue(collection: TplCollectionName, data: Record<string, any>): any;
+    extract(type: ForgeFieldTypes, fieldRule: IDbFieldRules): Partial<IDbForgeFields<T>>;
+    fks(collection: string): {
+        [collection: string]: IdaeTemplate;
+    };
+    reverseFks(targetCollection: TplCollectionName): Record<string, any>;
+    iterateArrayField(collection: TplCollectionName, fieldName: string, data: T[]): IDbForgeFields<T>[];
+    iterateObjectField(collection: TplCollectionName, fieldName: keyof T, data: Record<string, any>): IDbForgeFields<T>[];
+}
+export declare const IdaeModel: IdaeModelCore<Record<string, any>>;
+export declare class IDbCollectionValues<T extends Record<string, any>> {
+    #private;
+    dbCollections: IdaeModelCore;
+    private collection;
+    constructor(collection: TplCollectionName, idaeModel: IdaeModelRoot);
+    presentation(data: T): string;
+    indexValue(data: Record<string, unknown>): unknown | null;
+    format(fieldName: keyof T, data: T): string;
+    getInputDataSet(fieldName: string, data: T): Record<`data-${'collection' | 'collectionId' | 'fieldName' | 'fieldType' | 'fieldArgs'}`, string>;
+    iterateArrayField(fieldName: keyof IdaeTemplateFields, data: any[]): IDbForgeFields[];
+    iterateObjectField(fieldName: keyof IdaeTemplateFields, data: Record<string, any>): IDbForgeFields[];
+}
+export declare class IDbCollectionFieldValues<T extends Record<string, any>> {
+    #private;
+    constructor(collection: TplCollectionName, data: T[]);
+    format(fieldName: keyof T): string | string[];
+    getInputDataSet(fieldName: keyof T): Record<"data-collection" | "data-fieldName" | "data-fieldType" | "data-fieldArgs" | "data-collectionId", string>;
+    getForge(fieldName: keyof T): IDbForgeFields | undefined;
+    iterateArray(fieldName: string, data: any[]): IDbForgeFields[];
+    iterateObject(fieldName: string, data: Record<string, any>): IDbForgeFields[];
+}
+export declare class IDbCollectionFieldForge<T extends Record<string, any>> {
+    #private;
+    constructor(collection: TplCollectionName, fieldName: any, data: T);
+    get format(): string;
+    get inputDataSet(): Record<"data-collection" | "data-fieldName" | "data-fieldType" | "data-fieldArgs" | "data-collectionId", string>;
+    get forge(): IDbForgeFields<T> | undefined;
+    get fieldArgs(): IDbForgeArgs | undefined;
+    get fieldType(): IDbFieldType | undefined;
+    /**
+     * will return  text.inputBase  for ['url', 'email', 'number', 'date', 'time', 'datetime', 'phone', 'password']
+     */
+    get htmlInputType(): string | 'text' | 'area';
+    get rawData(): T;
+    iterateArray(fieldName: string, data: any[]): IDbForgeFields<T>[];
+    iterateObject(fieldName: string, data: Record<string, any>): IDbForgeFields<T>[];
+}

package/dist/dataTemplate/dataTemplate.js

@@ -0,0 +1,443 @@
+import { AccessProperties } from './types.js';
+export const exampleModel = {
+    agent: {
+        template: {
+            index: 'id',
+            presentation: 'name model',
+            fields: {
+                id: 'id (readonly)',
+                name: 'text (private)',
+                code: 'text',
+                model: 'text',
+                prompt: 'text-long',
+                created_at: 'date (private)',
+                ia_lock: 'boolean (private)',
+                agentPromptId: 'fk-agentPrompt.id (required)'
+            },
+            fks: {
+                agentPrompt: {
+                    code: 'agentPrompt',
+                    rules: 'readonly private',
+                    multiple: true
+                }
+            }
+        }
+    }
+};
+// renammed from IDbFields to IDbCollections to IdaeModel
+export class IdaeModelCore {
+    model;
+    constructor() { }
+    setModel(model) {
+        this.model = model;
+    }
+    addCollectionTemplate(collection, template) {
+        this.model[collection]['template'] = template;
+    }
+    parseAllCollections() {
+        let out = {};
+        Object.keys(this.model).forEach((collection) => {
+            out[collection] = this.parseRawCollection(collection);
+        });
+        return out;
+    }
+    parseRawCollection(collection) {
+        const fields = this.getCollectionTemplateFields(collection);
+        if (!fields)
+            return;
+        let out = {};
+        Object.keys(fields).forEach((fieldName) => {
+            let fieldType = fields[fieldName];
+            if (fieldType) {
+                out[fieldName] = this.parseCollectionFieldName(collection, fieldName);
+            }
+        });
+        return out;
+    }
+    parseCollectionFieldName(collection, fieldName) {
+        const field = this.#getTemplateFieldRule(collection, fieldName);
+        if (!field) {
+            IDbError.throwError(`Field ${fieldName} not found in collection ${collection}`, 'FIELD_NOT_FOUND');
+            return undefined;
+        }
+        const fieldType = this.testIs('primitive', field) ??
+            this.testIs('array', field) ??
+            this.testIs('object', field) ??
+            this.testIs('fk', field);
+        return this.forge({ collection, fieldName, ...fieldType });
+    }
+    parsFieldRule(fieldRule) {
+        if (!fieldRule)
+            return;
+        const fieldType = this.testIs('primitive', fieldRule) ??
+            this.testIs('array', fieldRule) ??
+            this.testIs('object', fieldRule) ??
+            this.testIs('fk', fieldRule);
+        return fieldType;
+    }
+    forge({ collection, fieldName, fieldType, fieldRule, fieldArgs, is }) {
+        return {
+            collection,
+            fieldName,
+            fieldType,
+            fieldRule,
+            fieldArgs,
+            is
+        };
+    }
+    #getModel() {
+        return this.model;
+    }
+    getCollection(collection) {
+        return this.#getModel()[String(collection)];
+    }
+    getCollectionTemplate(collection) {
+        return this.getCollection(collection)['template'];
+    }
+    getCollectionTemplateFks(collection) {
+        return this.getCollection(collection)['template']?.fks;
+    }
+    getIndexName(collection) {
+        return this.getCollection(collection)?.template?.index;
+    }
+    getCollectionTemplateFields(collection) {
+        return this.getCollectionTemplate(collection)?.fields;
+    }
+    getTemplatePresentation(collection) {
+        return this.getCollectionTemplate(collection)?.presentation;
+    }
+    #getTemplateFieldRule(collection, fieldName) {
+        return this.getCollectionTemplateFields(collection)?.[String(fieldName)];
+    }
+    getFkFieldType(string) {
+        const [collection, field] = string.split('.');
+        const template = this.#getTemplateFieldRule(collection, field);
+        return template;
+    }
+    getFkTemplateFields(string) {
+        const [collection, field] = string.split('.');
+        return this.getCollection(collection).template?.fields;
+    }
+    testIs(what, fieldRule) {
+        const typeMappings = {
+            fk: 'fk-',
+            array: 'array-of-',
+            object: 'object-',
+            primitive: ''
+        };
+        const prefix = typeMappings[what];
+        if (fieldRule.startsWith(prefix)) {
+            return this.is(what, fieldRule);
+        }
+        return undefined;
+    }
+    is(what, fieldRule) {
+        return this.extract(what, fieldRule);
+    }
+    indexValue(collection, data) {
+        const presentation = this.getIndexName(collection);
+        return data[presentation];
+    }
+    extract(type, fieldRule) {
+        // fieldType
+        function extractAfter(pattern, source) {
+            // remove all between () on source
+            const reg = source?.split('(')?.[0];
+            return reg.split(pattern)[1];
+        }
+        function extractArgs(source) {
+            const [piece, remaining] = source.split('(');
+            if (!remaining)
+                return { piece: piece.trim(), args: undefined };
+            const [central] = remaining?.split(')');
+            const args = central?.split(' ');
+            // console.log({ piece, args });
+            return { piece: piece.trim(), args };
+        }
+        const extractedArgs = extractArgs(fieldRule);
+        const fieldArgs = extractedArgs?.args;
+        let fieldType;
+        let is = extractedArgs?.piece;
+        switch (type) {
+            case 'array':
+                fieldType = extractAfter('array-of-', fieldRule);
+                is = is ?? fieldType;
+                break;
+            case 'object':
+                fieldType = extractAfter('object-', fieldRule);
+                is = is ?? fieldType;
+                break;
+            case 'fk':
+                fieldType = this.getFkFieldType(extractAfter('fk-', fieldRule));
+                is = extractedArgs?.piece;
+                break;
+            case 'primitive':
+                fieldType = extractedArgs?.piece;
+                is = is ?? fieldType;
+                break;
+        }
+        return { fieldType, fieldRule, fieldArgs, is: type };
+    }
+    fks(collection) {
+        const fks = this.getCollectionTemplateFks(collection);
+        const out = {};
+        // loop over fks
+        if (fks) {
+            Object.keys(fks).forEach((collection) => {
+                out[collection] = this.parseRawCollection(collection);
+            });
+        }
+        return out;
+    }
+    reverseFks(targetCollection) {
+        const result = {};
+        Object.entries(this.#getModel()).forEach(([collectionName, collectionModel]) => {
+            const template = collectionModel.template;
+            if (template && template.fks) {
+                Object.entries(template.fks).forEach(([fkName, fkConfig]) => {
+                    if (fkConfig?.code === targetCollection) {
+                        if (!result[collectionName]) {
+                            result[collectionName] = {};
+                        }
+                        result[collectionName][fkName] = fkConfig;
+                    }
+                });
+            }
+        });
+        return result;
+    }
+    // iterate base
+    iterateArrayField(collection, fieldName, data) {
+        const fieldInfo = this.parseCollectionFieldName(collection, fieldName);
+        if (fieldInfo?.is !== 'array' || !Array.isArray(data)) {
+            return [];
+        }
+        return data.map(() => this.parseCollectionFieldName(collection, fieldName)) ?? [];
+    }
+    iterateObjectField(collection, fieldName, data) {
+        const fieldInfo = this.parseCollectionFieldName(collection, fieldName);
+        if (fieldInfo?.is !== 'object' || typeof data !== 'object') {
+            return [];
+        }
+        return Object.keys(data).map((key) => this.parseCollectionFieldName(collection, key));
+    }
+}
+export const IdaeModel = new IdaeModelCore();
+IdaeModel.setModel(exampleModel);
+IdaeModel.getIndexName('users');
+IdaeModel.is('array', 'array-of-text-long(private required)');
+IdaeModel.reverseFks('users');
+IdaeModel.getFkFieldType('collectio.ners');
+// display field values, based on schema and provided data
+// renamed from iDBFieldValues to iDbCollectionValues
+// path D:\boulot\python\wollama\src\lib\db\dbFields.ts
+export class IDbCollectionValues {
+    dbCollections;
+    collection;
+    constructor(collection, idaeModel) {
+        this.collection = collection;
+        this.dbCollections = new IdaeModelCore(idaeModel);
+    }
+    presentation(data) {
+        try {
+            this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
+            const presentation = this.dbCollections.getTemplatePresentation(this.collection);
+            this.#checkError(!presentation, 'Presentation template not found', 'TEMPLATE_NOT_FOUND');
+            const fields = presentation.split(' ');
+            return fields
+                .map((field) => {
+                const value = data[field];
+                return value !== null && value !== undefined ? String(value) : '';
+            })
+                .join(' ');
+        }
+        catch (error) {
+            IDbError.handleError(error);
+            return '';
+        }
+    }
+    indexValue(data) {
+        try {
+            this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
+            const indexName = this.dbCollections.getIndexName(this.collection);
+            this.#checkError(!indexName, 'Index not found for collection', 'INDEX_NOT_FOUND');
+            this.#checkError(!(indexName in data), `Index field ${indexName} not found in data`, 'FIELD_NOT_FOUND');
+            return data[indexName];
+        }
+        catch (error) {
+            IDbError.handleError(error);
+            return null;
+        }
+    }
+    format(fieldName, data) {
+        try {
+            this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
+            this.#checkError(!(fieldName in data), `Field ${String(fieldName)} not found in data`, 'FIELD_NOT_FOUND');
+            const fieldInfo = this.dbCollections.parseCollectionFieldName(this.collection, fieldName);
+            this.#checkError(!fieldInfo, `Field ${String(fieldName)} not found in collection`, 'FIELD_NOT_FOUND');
+            switch (fieldInfo?.fieldType) {
+                case 'number':
+                    return this.#formatNumberField(data[fieldName]);
+                case 'text':
+                case 'text-tiny':
+                case 'text-short':
+                case 'text-medium':
+                case 'text-long':
+                case 'text-giant':
+                    return this.#formatTextField(data[fieldName], fieldInfo.fieldType);
+                default:
+                    return String(data[fieldName]);
+            }
+        }
+        catch (error) {
+            IDbError.handleError(error);
+            return '';
+        }
+    }
+    getInputDataSet(fieldName, data) {
+        const fieldInfo = this.dbCollections.parseCollectionFieldName(this.collection, fieldName);
+        const fieldType = fieldInfo?.fieldType ?? '';
+        const fieldArgs = fieldInfo?.fieldArgs?.join(' ') ?? '';
+        const indexName = this.dbCollections.getIndexName(this.collection);
+        return {
+            'data-collection': this.collection,
+            'data-collectionId': indexName && data?.[indexName] !== undefined ? String(data?.[indexName]) : '',
+            'data-fieldName': String(fieldName),
+            'data-fieldType': fieldType,
+            'data-fieldArgs': fieldArgs
+        };
+    }
+    iterateArrayField(fieldName, data) {
+        return this.dbCollections.iterateArrayField(this.collection, fieldName, data);
+    }
+    iterateObjectField(fieldName, data) {
+        return this.dbCollections.iterateObjectField(this.collection, fieldName, data);
+    }
+    #formatNumberField(value) {
+        // Implement number formatting logic here
+        return value.toString();
+    }
+    #formatTextField(value, type) {
+        const lengths = {
+            'text-tiny': 10,
+            'text-short': 20,
+            'text-medium': 30,
+            'text-long': 40,
+            'text-giant': 50
+        };
+        const maxLength = lengths[type] || value.length;
+        return value.substring(0, maxLength);
+    }
+    #checkAccess() {
+        // Implement access check logic here
+        return true;
+    }
+    #checkError(condition, message, code) {
+        if (condition) {
+            IDbError.throwError(message, code);
+        }
+    }
+}
+export class IDbCollectionFieldValues {
+    #collection;
+    #collectionValues;
+    #data;
+    constructor(collection, data) {
+        this.#collection = collection;
+        this.#collectionValues = new IDbCollectionValues(collection);
+        this.#data = data;
+    }
+    format(fieldName) {
+        const fieldInfo = this.#collectionValues.dbCollections.parseCollectionFieldName(this.#collection, fieldName);
+        if (fieldInfo?.is === 'array') {
+            return this.iterateArray(String(fieldName), this.#data);
+        }
+        if (fieldInfo?.is === 'object') {
+            return this.iterateObject(String(fieldName), this.#data);
+        }
+        return this.#collectionValues.format(fieldName, this.#data);
+    }
+    getInputDataSet(fieldName) {
+        return this.#collectionValues.getInputDataSet(String(fieldName), this.#data);
+    }
+    // renamed from parseCollectionFieldName
+    getForge(fieldName) {
+        return this.#collectionValues.dbCollections.parseCollectionFieldName(this.#collection, String(fieldName));
+    }
+    iterateArray(fieldName, data) {
+        return this.#collectionValues.iterateArrayField(fieldName, data);
+    }
+    iterateObject(fieldName, data) {
+        return this.#collectionValues.iterateObjectField(fieldName, data);
+    }
+}
+export class IDbCollectionFieldForge {
+    #collection;
+    #collectionValues;
+    #fieldName;
+    #data;
+    constructor(collection, fieldName, data) {
+        this.#collection = collection;
+        this.#collectionValues = new IDbCollectionValues(collection);
+        this.#fieldName = String(fieldName);
+        this.#data = data;
+    }
+    get format() {
+        return this.#collectionValues.format(String(this.#fieldName), this.#data);
+    }
+    get inputDataSet() {
+        return this.#collectionValues.getInputDataSet(String(this.#fieldName), this.#data);
+    }
+    // renamed from parseCollectionFieldName
+    get forge() {
+        return this.#collectionValues.dbCollections.parseCollectionFieldName(this.#collection, String(this.#fieldName));
+    }
+    get fieldArgs() {
+        return this.forge?.fieldArgs;
+    }
+    get fieldType() {
+        return this.forge?.fieldType;
+    }
+    /**
+     * will return  text.inputBase  for ['url', 'email', 'number', 'date', 'time', 'datetime', 'phone', 'password']
+     */
+    get htmlInputType() {
+        const variant = this?.fieldType?.split('text-')?.[1] ?? this.fieldType;
+        if (variant === 'area')
+            return variant;
+        if (this.forge?.fieldType?.startsWith('text-'))
+            return 'text';
+        if (['url', 'email', 'number', 'date', 'time', 'datetime', 'phone', 'password'].includes(this.forge?.fieldType ?? '')) {
+            return this.forge?.fieldType?.trim?.() ?? 'text';
+        }
+        return 'text';
+    }
+    get rawData() {
+        return this.#data;
+    }
+    iterateArray(fieldName, data) {
+        return this.#collectionValues.iterateArrayField(fieldName, data);
+    }
+    iterateObject(fieldName, data) {
+        return this.#collectionValues.iterateObjectField(fieldName, data);
+    }
+}
+class IDbError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'DbCollectionError';
+    }
+    static throwError(message, code) {
+        throw new IDbError(message, code);
+    }
+    static handleError(error) {
+        if (error instanceof IDbError) {
+            console.error(`${error.name}: ${error.message} (Code: ${error.code})`);
+        }
+        else {
+            console.error('Unexpected error:', error);
+        }
+    }
+}

package/dist/dataTemplate/types.d.ts

@@ -0,0 +1,74 @@
+type CombineElements<T extends string = string, U extends string = T> = T extends any ? T | `${T} ${CombineElements<Exclude<U, T>>}` : never;
+type CombinedArgs = CombineElements<AccessProperties>;
+type IdbObjectify<T extends string = 'number'> = `array-of-${T}` | `object-${T}`;
+export type TplCollectionName = string;
+export type TemplateFieldPrimitive = keyof typeof enumFieldsPrimitives | `text-${'tiny' | 'short' | 'medium' | 'long' | 'area'}` | `${string}.${string}` | `fk-${string}.${string}`;
+export type TplObjectFieldPrimitive = IdbObjectify<TemplateFieldPrimitive>;
+export type TplFieldFk = `fk-${string}.${string}`;
+export type TplFkObject = IdbObjectify<TplFieldFk>;
+export type TplTypes = TemplateFieldPrimitive | TplObjectFieldPrimitive | TplFieldFk | TplFkObject;
+export type TplFieldArgs = `${TplTypes} (${CombinedArgs})`;
+export type TplFieldRules = TplFieldArgs | TplTypes;
+export type IDbObjectPrimitive = IdbObjectify<TemplateFieldPrimitive>;
+export type IDbFk = `fk-${string}.${string}`;
+export type IDbFkObject = IdbObjectify<IDbFk>;
+export type IDbTypes = TemplateFieldPrimitive | IDbObjectPrimitive | IDbFk | IDbFkObject;
+export type IDBArgumentsTypes = `${IDbTypes}(${CombinedArgs})`;
+export type IDbFieldRules = IDBArgumentsTypes | IDbTypes;
+export type IDbFieldType = IDBArgumentsTypes | IDbTypes;
+export type CoreModel<T> = {
+    template: IdaeTemplate<T[keyof T]>;
+};
+export type IdaeModelRoot<T = Record<string, any>> = Record<string, any> & {
+    [K in keyof T]: {
+        template?: IdaeTemplate<T[K]>;
+    };
+};
+export type IdaeTemplate<C = Record<string, any>, M = IdaeModelRoot> = {
+    index: string;
+    presentation: CombineElements<keyof C>;
+    fields: IdaeTemplateFields<C>;
+    fks: {
+        [K in M]?: {
+            code: K;
+            multiple: boolean;
+            rules: CombinedArgs;
+        };
+    };
+};
+export type IdaeTemplateFields<T> = {
+    [K in keyof T]: TplFieldRules;
+};
+export type IDbForgeArgs = keyof typeof AccessProperties;
+export type IDbForgeFields<Collection> = {
+    collection?: TplCollectionName;
+    fieldName?: keyof Collection;
+    fieldType?: IDbFieldType;
+    fieldRule?: IDbFieldRules;
+    fieldArgs?: IDbForgeArgs | undefined;
+    is: string;
+};
+export type IDBTemplate<T> = {
+    [K in keyof T]: TplFieldRules;
+};
+export declare enum AccessProperties {
+    'private' = "private",
+    'readonly' = "readonly",
+    'required' = "required"
+}
+export declare enum enumFieldsPrimitives {
+    id = "id",
+    any = "any",
+    date = "date",
+    datetime = "datetime",
+    time = "time",
+    text = "text",
+    number = "number",
+    boolean = "boolean",
+    url = "url",
+    email = "email",
+    phone = "phone",
+    password = "password"
+}
+export type ForgeFieldTypes = 'primitive' | 'object' | 'array' | 'fk';
+export {};

package/dist/dataTemplate/types.js

@@ -0,0 +1,21 @@
+export var AccessProperties;
+(function (AccessProperties) {
+    AccessProperties["private"] = "private";
+    AccessProperties["readonly"] = "readonly";
+    AccessProperties["required"] = "required";
+})(AccessProperties || (AccessProperties = {}));
+export var enumFieldsPrimitives;
+(function (enumFieldsPrimitives) {
+    enumFieldsPrimitives["id"] = "id";
+    enumFieldsPrimitives["any"] = "any";
+    enumFieldsPrimitives["date"] = "date";
+    enumFieldsPrimitives["datetime"] = "datetime";
+    enumFieldsPrimitives["time"] = "time";
+    enumFieldsPrimitives["text"] = "text";
+    enumFieldsPrimitives["number"] = "number";
+    enumFieldsPrimitives["boolean"] = "boolean";
+    enumFieldsPrimitives["url"] = "url";
+    enumFieldsPrimitives["email"] = "email";
+    enumFieldsPrimitives["phone"] = "phone";
+    enumFieldsPrimitives["password"] = "password";
+})(enumFieldsPrimitives || (enumFieldsPrimitives = {}));

package/dist/dataTemplate/validator.d.ts

@@ -0,0 +1,33 @@
+import { type IdaeTemplateFields } from './types.js';
+/**
+ * IDbFormValidate
+ *
+ *
+ */
+export declare class IDbFormValidate<T> {
+    #private;
+    private collection;
+    private dbFields;
+    constructor(collection: string);
+    validateField(fieldName: keyof IdaeTemplateFields<T>, value: string): {
+        isValid: boolean;
+        error?: string;
+    };
+    validateFieldValue(fieldName: keyof IdaeTemplateFields, value: any): boolean;
+    validateForm(formData: Record<string, unknown>, options?: {
+        ignoreFields?: string[] | undefined;
+    }): {
+        isValid: boolean;
+        errors: Record<string, string>;
+        invalidFields: string[];
+    };
+    private validateEmail;
+    private validateUrl;
+    private validatePhone;
+    private validateDateTime;
+}
+export declare class IDbValidationError extends Error {
+    field: string;
+    code: string;
+    constructor(field: string, code: string, message: string);
+}

package/dist/dataTemplate/validator.js

@@ -0,0 +1,172 @@
+import { IdaeTemplateModel } from './dataTemplate.js';
+import { enumFieldsPrimitives } from './types.js';
+/**
+ * IDbFormValidate
+ *
+ *
+ */
+export class IDbFormValidate {
+    collection;
+    dbFields;
+    constructor(collection) {
+        this.collection = collection;
+        this.dbFields = new IdaeModel();
+    }
+    validateField(fieldName, value) {
+        try {
+            const fieldInfo = this.dbFields.parseCollectionFieldName(this.collection, fieldName);
+            if (!fieldInfo) {
+                return { isValid: false, error: `Field ${String(fieldName)} not found in collection` };
+            }
+            // Vérification du type
+            if (!this.#validateType(value, fieldInfo.fieldType)) {
+                return this.#returnError(fieldName, fieldInfo.fieldType);
+            }
+            // Vérification des arguments du champ (required, etc.)
+            if (fieldInfo.fieldArgs) {
+                for (const arg of fieldInfo.fieldArgs) {
+                    if (arg === 'required' && (value === undefined || value === null || value === '')) {
+                        return this.#returnError(fieldName, 'required');
+                    }
+                }
+            }
+            // Validations spécifiques selon le type de champ
+            switch (fieldInfo.fieldType) {
+                case enumFieldsPrimitives.email:
+                    if (!this.validateEmail(value)) {
+                        return this.#returnError(fieldName, fieldInfo.fieldType);
+                    }
+                    break;
+                case enumFieldsPrimitives.url:
+                    if (!this.validateUrl(value)) {
+                        return this.#returnError(fieldName, fieldInfo.fieldType);
+                    }
+                    break;
+                case enumFieldsPrimitives.phone:
+                    if (!this.validatePhone(value)) {
+                        return this.#returnError(fieldName, fieldInfo.fieldType);
+                    }
+                    break;
+                case enumFieldsPrimitives.date:
+                case enumFieldsPrimitives.datetime:
+                case enumFieldsPrimitives.time:
+                    if (!this.validateDateTime(value, fieldInfo.fieldType)) {
+                        return this.#returnError(fieldName, fieldInfo.fieldType);
+                    }
+                    break;
+                // Ajoutez d'autres cas spécifiques ici
+            }
+            return { isValid: true };
+        }
+        catch (error) {
+            if (error instanceof IDbValidationError) {
+                return { isValid: false, error: error.message };
+            }
+            throw error;
+        }
+    }
+    validateFieldValue(fieldName, value) {
+        try {
+            this.validateField(fieldName, value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    validateForm(formData, options = {}) {
+        const errors = {};
+        const invalidFields = [];
+        let isValid = true;
+        const fields = this.dbFields.getCollectionTemplateFields(this.collection);
+        if (!fields) {
+            return {
+                isValid: false,
+                errors: { general: 'Collection template not found' },
+                invalidFields: ['general']
+            };
+        }
+        for (const [fieldName, fieldRule] of Object.entries(fields)) {
+            // Ignorer les champs spécifiés dans options.ignoreFields
+            if (options.ignoreFields && options.ignoreFields.includes(fieldName)) {
+                continue;
+            }
+            const result = this.validateField(fieldName, formData[fieldName]);
+            if (!result.isValid) {
+                errors[fieldName] = result.error || 'Invalid field';
+                invalidFields.push(fieldName);
+                isValid = false;
+            }
+        }
+        return { isValid, errors, invalidFields };
+    }
+    #validateType(value, type) {
+        switch (type) {
+            case enumFieldsPrimitives.number:
+                return typeof value === 'number' && !isNaN(value);
+            case enumFieldsPrimitives.boolean:
+                return typeof value === 'boolean';
+            case enumFieldsPrimitives.text:
+            case enumFieldsPrimitives.email:
+            case enumFieldsPrimitives.url:
+            case enumFieldsPrimitives.phone:
+            case enumFieldsPrimitives.password:
+                return typeof value === 'string';
+            case enumFieldsPrimitives.date:
+            case enumFieldsPrimitives.datetime:
+            case enumFieldsPrimitives.time:
+                return value instanceof Date || typeof value === 'string';
+            case enumFieldsPrimitives.any:
+                return true;
+            default:
+                return true; // Pour les types non gérés, on considère que c'est valide
+        }
+    }
+    #returnError(fieldName, enumCode) {
+        throw new IDbValidationError(String(fieldName), enumCode ?? 'unknown', `Invalid format for field ${String(fieldName)}. Cause "${enumCode}" `);
+    }
+    validateEmail(email) {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(email);
+    }
+    validateUrl(url) {
+        try {
+            new URL(url);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    validatePhone(phone) {
+        // Ceci est un exemple simple. Vous pouvez ajuster selon vos besoins spécifiques
+        const phoneRegex = /^\+?[\d\s-]{10,}$/;
+        return phoneRegex.test(phone);
+    }
+    validateDateTime(value, type) {
+        const date = value instanceof Date ? value : new Date(value);
+        if (isNaN(date.getTime()))
+            return false;
+        switch (type) {
+            case enumFieldsPrimitives.date:
+                return true; // La conversion en Date a déjà validé le format
+            case enumFieldsPrimitives.time:
+                // Vérifiez si la chaîne contient uniquement l'heure
+                return /^([01]\d|2[0-3]):([0-5]\d)(:([0-5]\d))?$/.test(value);
+            case enumFieldsPrimitives.datetime:
+                return true; // La conversion en Date a déjà validé le format
+            default:
+                return false;
+        }
+    }
+}
+export class IDbValidationError extends Error {
+    field;
+    code;
+    constructor(field, code, message) {
+        super(message);
+        this.field = field;
+        this.code = code;
+        this.name = 'IDbValidationError';
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './dataTemplate/dataTemplate.js';
+export * from './dataTemplate/types.js';
+export * from './dataTemplate/validator.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+// Reexport your entry components here
+export * from './dataTemplate/dataTemplate.js';
+export * from './dataTemplate/types.js';
+export * from './dataTemplate/validator.js';

package/package.json

@@ -0,0 +1,56 @@
+{
+	"name": "@medyll/idae-data-tpl",
+	"scope": "@medyll",
+	"version": "0.1.0",
+	"scripts": {
+		"dev": "vite dev",
+		"build": "vite build && npm run package",
+		"preview": "vite preview",
+		"package": "svelte-kit sync && svelte-package && publint",
+		"prepublishOnly": "npm run package",
+		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+		"test": "vitest",
+		"lint": "prettier --check . && eslint .",
+		"format": "prettier --write ."
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"svelte": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"!dist/**/*.test.*",
+		"!dist/**/*.spec.*"
+	],
+	"peerDependencies": {
+		"svelte": "^5.0.0-next.1"
+	},
+	"devDependencies": {
+		"@sveltejs/adapter-auto": "^3.0.0",
+		"@sveltejs/kit": "^2.0.0",
+		"@sveltejs/package": "^2.0.0",
+		"@sveltejs/vite-plugin-svelte": "^3.0.0",
+		"@types/eslint": "^8.56.7",
+		"eslint": "^9.0.0",
+		"eslint-config-prettier": "^9.1.0",
+		"eslint-plugin-svelte": "^2.36.0",
+		"glob": "^7.2.0",
+		"globals": "^15.0.0",
+		"prettier": "^3.1.1",
+		"prettier-plugin-svelte": "^3.1.2",
+		"publint": "^0.1.9",
+		"svelte": "^4.2.7",
+		"svelte-check": "^3.6.0",
+		"tslib": "^2.4.1",
+		"typescript": "^5.0.0",
+		"typescript-eslint": "^8.0.0-alpha.20",
+		"vite": "^5.0.11",
+		"vitest": "^1.2.0"
+	},
+	"svelte": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"type": "module"
+}