@solidev/data 0.0.1-alpha.0

package/esm2020/lib/data/fields/base.mjs

@@ -0,0 +1,142 @@
+import 'reflect-metadata';
+import { FormControl, Validators } from '@angular/forms';
+export const PROPERTY_METADATA_KEY = Symbol('ngxDataMetadata');
+/**
+ * Base field manager, stores metadata and provides common field utilities
+ *
+ * - name : field name, should be the same in data structure and model
+ * - help : field help text, blank by default
+ * - description : field name for humans
+ * - readonly : field is readonly (cannot be changed / pushed to api)
+ * - default : default value for field
+ *
+ * - editor_type : editor type
+ * - display_type : display type
+ *
+ * - fromJson(data) : deserializer
+ * - toJson(data) : serialiser
+ * - toString(data,format) : to string, for display
+ *
+ * - formControl : returns field form control
+ * - validators : returns field validator
+ */
+export class BaseFieldManager {
+    constructor(params) {
+        this.required = false;
+        this.readonly = false;
+        this.editorType = 'input.text';
+        this.displayType = 'text';
+        Object.assign(this, params);
+        if (!this.name) {
+            this.name = 'noname';
+        }
+        if (!this.description) {
+            this.description = this.name;
+        }
+        if (!this.help) {
+            this.help = '';
+        }
+        this.getDefaultValue();
+    }
+    /** Return field validators */
+    get validators() {
+        return this.getValidators();
+    }
+    /** Returns current field name */
+    get fname() {
+        return this.name.split('__')[1] || this.name;
+    }
+    /** Create a new typed formControl for this field. */
+    formControl(instance) {
+        return new FormControl(instance[this.fname] || this.getDefaultValue(), this.validators);
+    }
+    /** JSON deserializer base method. */
+    fromJson(data) {
+        return data;
+    }
+    /** JSON serializer base method. */
+    toJson(data) {
+        return data;
+    }
+    /**
+     * Display value (as string)
+     * @param data
+     * @param format (not used)
+     */
+    toString(data, format = 'default') {
+        return `${data}`;
+    }
+    /** Return validators
+     *
+     * @protected
+     */
+    getValidators() {
+        const v = [];
+        if (this.required) {
+            v.push(Validators.required);
+        }
+        return v;
+    }
+    /**
+     * Returns default value for model, using args if needed.
+     * @param args
+     */
+    default(args = {}) {
+        return this.getDefaultValue(args);
+    }
+    /**
+     * Returns default value for model, using args if needed.
+     * @param args
+     * @protected
+     */
+    getDefaultValue(args = {}) {
+        if (this.defaultValue instanceof Function) {
+            return this.defaultValue(args);
+        }
+        if (this.required && this.defaultValue === undefined) {
+            throw new Error(`Field ${this.name} : no default value for required field`);
+        }
+        return this.defaultValue;
+    }
+}
+/** Util to get own object keys */
+const ownKeys = (target) => Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
+/**
+ * Creates a field decorator that can only be applied within
+ * an object containing a static __name property.
+ *
+ *
+ * @param meta field metadata
+ * @param type field type code
+ * @param manager field manager
+ */
+export function genericDataField(meta, type, manager) {
+    return (target, propertyKey) => {
+        const allMetadata = Reflect.getMetadata(PROPERTY_METADATA_KEY, target) ||
+            new Map();
+        let cname = `${target.constructor.__name}`;
+        if ((cname === `undefined` || cname === '') && type !== 'primaryField') {
+            throw Error(`Decorator ${type} allowed only on classes with static __name field : "${cname}" found for - ${target}`);
+        }
+        const pk = `${cname}__${String(propertyKey)}`;
+        let cm = allMetadata.get(pk);
+        /* istanbul ignore if */
+        if (cm) {
+            // This should never occur as metadata is object bound and property names must be unique
+            throw Error(`Field ${pk} already defined = ${cm}`);
+        }
+        cm = {};
+        for (const key of ownKeys(meta)) {
+            cm[key] = meta[key];
+        }
+        if (meta.name === undefined) {
+            cm.name = `${String(propertyKey)}`;
+        }
+        cm.type = type;
+        cm.self = pk;
+        cm.manager = new manager(cm);
+        allMetadata.set(pk, cm);
+        Reflect.defineMetadata(PROPERTY_METADATA_KEY, allMetadata, target);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../../../../projects/data/src/lib/data/fields/base.ts"],"names":[],"mappings":"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","sourcesContent":["import 'reflect-metadata';\nimport { FormControl, ValidatorFn, Validators } from '@angular/forms';\nimport { DataModel } from '../data-model';\nimport {\n  DISPEDIT_DISPLAY_TYPES,\n  DISPEDIT_EDITOR_TYPES,\n} from '../../dispedit/dispedit/dispedit.constants';\n\nexport const PROPERTY_METADATA_KEY = Symbol('ngxDataMetadata');\n\n/**\n * Descriptive info for all fields.\n * All are optional.\n */\nexport interface IFieldMetadata<FT> {\n  /** Field name (for display, column title, etc..) */\n  name?: string;\n  /** Field help text (for input) */\n  help?: string;\n  /** Field description (for details on hover etc..) */\n  description?: string;\n  /** Field required : no undefined allowed on save ? */\n  required?: boolean;\n  /** Field cannot be updated */\n  readonly?: boolean;\n  /** Default value */\n  defaultValue?: FT | ((args: any) => FT) | null;\n}\n\n/**\n * Base field manager, stores metadata and provides common field utilities\n *\n * - name : field name, should be the same in data structure and model\n * - help : field help text, blank by default\n * - description : field name for humans\n * - readonly : field is readonly (cannot be changed / pushed to api)\n * - default : default value for field\n *\n * - editor_type : editor type\n * - display_type : display type\n *\n * - fromJson(data) : deserializer\n * - toJson(data) : serialiser\n * - toString(data,format) : to string, for display\n *\n * - formControl : returns field form control\n * - validators : returns field validator\n */\nexport class BaseFieldManager<FT> implements IFieldMetadata<FT> {\n  /** Name is mandatory in a field manager. It is given by\n   * field decorator if not directly given in field manager. */\n  public name!: string;\n  public description!: string;\n  public help!: string;\n  public required = false;\n  public readonly = false;\n  public defaultValue?: FT | ((args: any) => FT);\n\n  public editorType: DISPEDIT_EDITOR_TYPES = 'input.text';\n  public displayType: DISPEDIT_DISPLAY_TYPES = 'text';\n\n  constructor(params: IFieldMetadata<FT>) {\n    Object.assign(this, params);\n    if (!this.name) {\n      this.name = 'noname';\n    }\n    if (!this.description) {\n      this.description = this.name;\n    }\n    if (!this.help) {\n      this.help = '';\n    }\n    this.getDefaultValue();\n  }\n\n  /** Return field validators */\n  public get validators(): ValidatorFn[] {\n    return this.getValidators();\n  }\n\n  /** Returns current field name */\n  public get fname(): string {\n    return this.name.split('__')[1] || this.name;\n  }\n\n  /** Create a new typed formControl for this field. */\n  public formControl(instance: DataModel): FormControl<FT | null> {\n    return new FormControl<FT>(\n      ((instance as any)[this.fname] as FT) || (this.getDefaultValue() as FT),\n      this.validators\n    );\n  }\n\n  /** JSON deserializer base method. */\n  public fromJson(data: any): FT {\n    return data as FT;\n  }\n\n  /** JSON serializer base method. */\n  public toJson(data: FT): any {\n    return data as any;\n  }\n\n  /**\n   * Display value (as string)\n   * @param data\n   * @param format (not used)\n   */\n  public toString(data: FT, format: string = 'default'): string {\n    return `${data}`;\n  }\n\n  /** Return validators\n   *\n   * @protected\n   */\n  protected getValidators(): ValidatorFn[] {\n    const v: ValidatorFn[] = [];\n    if (this.required) {\n      v.push(Validators.required);\n    }\n    return v;\n  }\n\n  /**\n   * Returns default value for model, using args if needed.\n   * @param args\n   */\n  public default(args: any = {}): FT | undefined {\n    return this.getDefaultValue(args);\n  }\n\n  /**\n   * Returns default value for model, using args if needed.\n   * @param args\n   * @protected\n   */\n  protected getDefaultValue(args: any = {}): FT | undefined {\n    if (this.defaultValue instanceof Function) {\n      return this.defaultValue(args);\n    }\n    if (this.required && this.defaultValue === undefined) {\n      throw new Error(\n        `Field ${this.name} : no default value for required field`\n      );\n    }\n    return this.defaultValue;\n  }\n}\n\n/**\n * Field data stored on reflected metadata.\n */\nexport interface IFieldStoredMetadata<FT> extends IFieldMetadata<FT> {\n  self: string;\n  name: string;\n  type: string;\n  manager: BaseFieldManager<FT>;\n}\n\n/** Util to get own object keys */\nconst ownKeys = (target: any): any =>\n  Object.getOwnPropertyNames(target).concat(\n    Object.getOwnPropertySymbols(target) as any\n  );\n\n/** Manager constructor\n *  FT is js field type;\n *  T is manager type\n * */\ntype BaseFieldManagerConstructor<FT, T extends BaseFieldManager<FT>> = new (\n  params: any\n) => T;\n\n/**\n * Field decorator function\n */\nexport type FieldDecoratorFn = (\n  target: any,\n  propertyKey: string | symbol\n) => void;\n\n/**\n * Creates a field decorator that can only be applied within\n * an object containing a static __name property.\n *\n *\n * @param meta field metadata\n * @param type field type code\n * @param manager field manager\n */\nexport function genericDataField<\n  FT,\n  MD extends IFieldMetadata<FT>,\n  MG extends BaseFieldManager<FT>\n>(\n  meta: MD,\n  type: string,\n  manager: BaseFieldManagerConstructor<FT, MG>\n): FieldDecoratorFn {\n  return (target: DataModel, propertyKey: string | symbol) => {\n    const allMetadata: Map<\n      string,\n      IFieldStoredMetadata<any>\n    > = Reflect.getMetadata(PROPERTY_METADATA_KEY, target) ||\n    new Map<string, IFieldStoredMetadata<any>>();\n    let cname: string = `${(target.constructor as any).__name}`;\n    if ((cname === `undefined` || cname === '') && type !== 'primaryField') {\n      throw Error(\n        `Decorator ${type} allowed only on classes with static __name field : \"${cname}\" found for - ${target}`\n      );\n    }\n    const pk = `${cname}__${String(propertyKey)}`;\n    let cm = allMetadata.get(pk);\n    /* istanbul ignore if */\n    if (cm) {\n      // This should never occur as metadata is object bound and property names must be unique\n      throw Error(`Field ${pk} already defined = ${cm}`);\n    }\n    cm = {} as IFieldStoredMetadata<any>;\n    for (const key of ownKeys(meta as any)) {\n      (cm as any)[key] = (meta as any)[key];\n    }\n    if (meta.name === undefined) {\n      cm.name = `${String(propertyKey)}`;\n    }\n    cm.type = type;\n    cm.self = pk;\n    cm.manager = new manager(cm);\n    allMetadata.set(pk, cm);\n    Reflect.defineMetadata(PROPERTY_METADATA_KEY, allMetadata, target);\n  };\n}\n"]}

package/esm2020/lib/data/fields/boolean.mjs

@@ -0,0 +1,38 @@
+import { BaseFieldManager, genericDataField } from './base';
+export class BooleanFieldManager extends BaseFieldManager {
+    constructor() {
+        super(...arguments);
+        this.editorType = 'input.checkbox';
+        this.displayType = 'boolean';
+    }
+    fromJson(data) {
+        if (data === undefined) {
+            if (this.required) {
+                return this.getDefaultValue();
+            }
+            else {
+                return null;
+            }
+        }
+        if (data === null) {
+            if (this.required) {
+                return this.getDefaultValue();
+            }
+            else {
+                return null;
+            }
+        }
+        if (typeof data === 'boolean') {
+            return data;
+        }
+        if (typeof data === 'string') {
+            if (['true', '1', 'ok', 'yes'].indexOf(data) !== -1) {
+                return true;
+            }
+            return ['false', '0', 'nok', 'no'].indexOf(data) === -1;
+        }
+        return !!data;
+    }
+}
+export const booleanField = (updates = {}) => genericDataField(updates, 'booleanField', BooleanFieldManager);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/data/fields/datetime.mjs

@@ -0,0 +1,124 @@
+import { BaseFieldManager, genericDataField } from './base';
+export const dateMinimum = (date) => {
+    return (control) => {
+        if (control.value == null) {
+            return null;
+        }
+        const controlDate = new Date(control.value);
+        const validationDate = date;
+        return controlDate > validationDate
+            ? null
+            : {
+                minDate: {
+                    'date-minimum': validationDate,
+                    actual: controlDate,
+                },
+            };
+    };
+};
+export const dateMaximum = (date) => {
+    return (control) => {
+        if (control.value == null) {
+            return null;
+        }
+        const controlDate = new Date(control.value);
+        const validationDate = date;
+        return controlDate < validationDate
+            ? null
+            : {
+                maxDate: {
+                    'date-maximum': validationDate,
+                    actual: controlDate,
+                },
+            };
+    };
+};
+export class DateFieldManager extends BaseFieldManager {
+    constructor() {
+        super(...arguments);
+        this.autoNow = false;
+        this.autoNowAdd = false;
+        this.editorType = 'input.date';
+        this.displayType = 'date';
+    }
+    get validators() {
+        const v = super.validators;
+        if (this.min) {
+            v.push(dateMinimum(this.min));
+        }
+        if (this.max) {
+            v.push(dateMaximum(this.max));
+        }
+        return v;
+    }
+    fromJson(data) {
+        if (data === null || data === undefined) {
+            return null;
+        }
+        const date = new Date(data);
+        if (date instanceof Date && !isNaN(date)) {
+            return date;
+        }
+        return null;
+    }
+    toJson(data) {
+        if (data === null || data === undefined) {
+            return null;
+        }
+        if (typeof data === 'string') {
+            const d = this.fromJson(data);
+            if (d === null) {
+                return null;
+            }
+            data = d;
+        }
+        return `${data.getUTCFullYear()}-${data.getUTCMonth() + 1}-${data.getUTCDate()}`;
+    }
+    /**
+     * Returns default value for model, using args if needed.
+     * @param args
+     * @protected
+     */
+    getDefaultValue(args = {}) {
+        if (this.defaultValue instanceof Function) {
+            return this.defaultValue(args);
+        }
+        if (this.required && this.defaultValue === undefined) {
+            throw new Error(`Field ${this.name} : no default value for required field`);
+        }
+        if (this.defaultValue === undefined) {
+            return this.autoNow || this.autoNowAdd ? new Date() : null;
+        }
+        return this.defaultValue;
+    }
+}
+export class DatetimeFieldManager extends DateFieldManager {
+    constructor() {
+        super(...arguments);
+        this.timezone = 'Europe/Paris';
+        this.editorType = 'input.datetime';
+        this.displayType = 'datetime';
+    }
+    toJson(data) {
+        if (data === null || data === undefined) {
+            return null;
+        }
+        if (typeof data === 'string') {
+            const d = this.fromJson(data);
+            if (d === null) {
+                return null;
+            }
+            data = d;
+        }
+        try {
+            return data.toISOString();
+        }
+        catch (e) {
+            console.error(e, data);
+            return null;
+        }
+    }
+}
+export const dateField = (updates = {}) => genericDataField(updates, 'dateField', DateFieldManager);
+export const datetimeField = (updates = {}) => genericDataField(updates, 'datetimeField', DatetimeFieldManager);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datetime.js","sourceRoot":"","sources":["../../../../../../projects/data/src/lib/data/fields/datetime.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseFieldManager, genericDataField, IFieldMetadata } from './base';\nimport {\n  DISPEDIT_DISPLAY_TYPES,\n  DISPEDIT_EDITOR_TYPES,\n} from '../../dispedit/dispedit/dispedit.constants';\nimport { AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';\n\nexport interface IDateFieldMetadata extends IFieldMetadata<Date | null> {\n  autoNow?: boolean;\n  autoNowAdd?: boolean;\n  min?: Date;\n  max?: Date;\n}\n\nexport const dateMinimum = (date: Date): ValidatorFn => {\n  return (control: AbstractControl): ValidationErrors | null => {\n    if (control.value == null) {\n      return null;\n    }\n\n    const controlDate = new Date(control.value);\n\n    const validationDate = date;\n\n    return controlDate > validationDate\n      ? null\n      : {\n          minDate: {\n            'date-minimum': validationDate,\n            actual: controlDate,\n          },\n        };\n  };\n};\n\nexport const dateMaximum = (date: Date): ValidatorFn => {\n  return (control: AbstractControl): ValidationErrors | null => {\n    if (control.value == null) {\n      return null;\n    }\n    const controlDate = new Date(control.value);\n    const validationDate = date;\n\n    return controlDate < validationDate\n      ? null\n      : {\n          maxDate: {\n            'date-maximum': validationDate,\n            actual: controlDate,\n          },\n        };\n  };\n};\n\nexport interface IDatetimeFieldMetadata extends IDateFieldMetadata {\n  timezone?: string;\n}\n\nexport class DateFieldManager extends BaseFieldManager<Date | null> {\n  public autoNow = false;\n  public autoNowAdd = false;\n  public min?: Date;\n  public max?: Date;\n  public override editorType: DISPEDIT_EDITOR_TYPES = 'input.date';\n  public override displayType: DISPEDIT_DISPLAY_TYPES = 'date';\n\n  public override get validators(): ValidatorFn[] {\n    const v = super.validators;\n    if (this.min) {\n      v.push(dateMinimum(this.min));\n    }\n    if (this.max) {\n      v.push(dateMaximum(this.max));\n    }\n    return v;\n  }\n\n  public override fromJson(data: any): Date | null {\n    if (data === null || data === undefined) {\n      return null;\n    }\n    const date = new Date(data);\n    if (date instanceof Date && !isNaN(date as any)) {\n      return date;\n    }\n    return null;\n  }\n\n  public override toJson(data: Date | string | null): null | string {\n    if (data === null || data === undefined) {\n      return null;\n    }\n    if (typeof data === 'string') {\n      const d = this.fromJson(data);\n      if (d === null) {\n        return null;\n      }\n      data = d;\n    }\n    return `${data.getUTCFullYear()}-${\n      data.getUTCMonth() + 1\n    }-${data.getUTCDate()}`;\n  }\n\n  /**\n   * Returns default value for model, using args if needed.\n   * @param args\n   * @protected\n   */\n  protected override getDefaultValue(args: any = {}): Date | null | undefined {\n    if (this.defaultValue instanceof Function) {\n      return this.defaultValue(args);\n    }\n    if (this.required && this.defaultValue === undefined) {\n      throw new Error(\n        `Field ${this.name} : no default value for required field`\n      );\n    }\n    if (this.defaultValue === undefined) {\n      return this.autoNow || this.autoNowAdd ? new Date() : null;\n    }\n    return this.defaultValue;\n  }\n}\n\nexport class DatetimeFieldManager\n  extends DateFieldManager\n  implements IDatetimeFieldMetadata\n{\n  public timezone = 'Europe/Paris';\n  public override editorType: DISPEDIT_EDITOR_TYPES = 'input.datetime';\n  public override displayType: DISPEDIT_DISPLAY_TYPES = 'datetime';\n\n  public override toJson(data: Date): string | null {\n    if (data === null || data === undefined) {\n      return null;\n    }\n    if (typeof data === 'string') {\n      const d = this.fromJson(data);\n      if (d === null) {\n        return null;\n      }\n      data = d;\n    }\n    try {\n      return data.toISOString();\n    } catch (e) {\n      console.error(e, data);\n      return null;\n    }\n  }\n}\n\nexport const dateField = (updates: IDateFieldMetadata = {}) =>\n  genericDataField(updates, 'dateField', DateFieldManager);\n\nexport const datetimeField = (updates: IDatetimeFieldMetadata = {}) =>\n  genericDataField(updates, 'datetimeField', DatetimeFieldManager);\n"]}

package/esm2020/lib/data/fields/index.mjs

@@ -0,0 +1,7 @@
+export { charField, emailField, textField, passwordField, } from './stringfields';
+export { primaryField } from './primaryfield';
+export { dateField, datetimeField } from './datetime';
+export { foreignKeyField, manyToManyField, reverseForeignKeyField, detailsField, } from './relations';
+export { booleanField } from './boolean';
+export { decimalField, integerField, floatField } from './numbers';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kYXRhL3NyYy9saWIvZGF0YS9maWVsZHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLFNBQVMsRUFDVCxVQUFVLEVBQ1YsU0FBUyxFQUNULGFBQWEsR0FDZCxNQUFNLGdCQUFnQixDQUFDO0FBQ3hCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUM5QyxPQUFPLEVBQUUsU0FBUyxFQUFFLGFBQWEsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUN0RCxPQUFPLEVBQ0wsZUFBZSxFQUNmLGVBQWUsRUFDZixzQkFBc0IsRUFDdEIsWUFBWSxHQUNiLE1BQU0sYUFBYSxDQUFDO0FBQ3JCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxZQUFZLEVBQUUsVUFBVSxFQUFFLE1BQU0sV0FBVyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtcbiAgY2hhckZpZWxkLFxuICBlbWFpbEZpZWxkLFxuICB0ZXh0RmllbGQsXG4gIHBhc3N3b3JkRmllbGQsXG59IGZyb20gJy4vc3RyaW5nZmllbGRzJztcbmV4cG9ydCB7IHByaW1hcnlGaWVsZCB9IGZyb20gJy4vcHJpbWFyeWZpZWxkJztcbmV4cG9ydCB7IGRhdGVGaWVsZCwgZGF0ZXRpbWVGaWVsZCB9IGZyb20gJy4vZGF0ZXRpbWUnO1xuZXhwb3J0IHtcbiAgZm9yZWlnbktleUZpZWxkLFxuICBtYW55VG9NYW55RmllbGQsXG4gIHJldmVyc2VGb3JlaWduS2V5RmllbGQsXG4gIGRldGFpbHNGaWVsZCxcbn0gZnJvbSAnLi9yZWxhdGlvbnMnO1xuZXhwb3J0IHsgYm9vbGVhbkZpZWxkIH0gZnJvbSAnLi9ib29sZWFuJztcbmV4cG9ydCB7IGRlY2ltYWxGaWVsZCwgaW50ZWdlckZpZWxkLCBmbG9hdEZpZWxkIH0gZnJvbSAnLi9udW1iZXJzJztcbiJdfQ==

package/esm2020/lib/data/fields/numbers.mjs

@@ -0,0 +1,38 @@
+import { BaseFieldManager, genericDataField, } from './base';
+import { Validators } from '@angular/forms';
+export class IntegerFieldManager extends BaseFieldManager {
+    constructor() {
+        super(...arguments);
+        this.displayType = 'text';
+        this.editorType = 'input.number';
+    }
+    get validators() {
+        const v = super.getValidators();
+        if (this.min !== undefined) {
+            v.push(Validators.min(this.min));
+        }
+        if (this.max !== undefined) {
+            v.push(Validators.max(this.max));
+        }
+        return v;
+    }
+}
+export class FloatFieldManager extends IntegerFieldManager {
+    constructor() {
+        super(...arguments);
+        this.displayType = 'text';
+        this.editorType = 'input.number';
+    }
+}
+export class DecimalFieldManager extends IntegerFieldManager {
+    constructor() {
+        super(...arguments);
+        this.displayType = 'decimal';
+        this.editorType = 'input.decimal';
+    }
+}
+/* eslint-disable max-len */
+export const integerField = (updates = {}) => genericDataField(updates, 'integerField', IntegerFieldManager);
+export const floatField = (updates = {}) => genericDataField(updates, 'floatField', FloatFieldManager);
+export const decimalField = (updates = { factor: 100 }) => genericDataField(updates, 'decimalField', DecimalFieldManager);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/data/fields/primaryfield.mjs

@@ -0,0 +1,9 @@
+import { BaseFieldManager, genericDataField, } from './base';
+export class PrimaryFieldManager extends BaseFieldManager {
+    constructor() {
+        super(...arguments);
+        this.step = 1;
+    }
+}
+export const primaryField = (updates = {}) => genericDataField(updates, 'primaryField', PrimaryFieldManager);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpbWFyeWZpZWxkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZGF0YS9zcmMvbGliL2RhdGEvZmllbGRzL3ByaW1hcnlmaWVsZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsZ0JBQWdCLEVBRWhCLGdCQUFnQixHQUVqQixNQUFNLFFBQVEsQ0FBQztBQU1oQixNQUFNLE9BQU8sbUJBQ1gsU0FBUSxnQkFBd0I7SUFEbEM7O1FBSVMsU0FBSSxHQUFHLENBQUMsQ0FBQztJQUNsQixDQUFDO0NBQUE7QUFFRCxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsQ0FDMUIsVUFBaUMsRUFBRSxFQUNqQixFQUFFLENBQ3BCLGdCQUFnQixDQUFDLE9BQU8sRUFBRSxjQUFjLEVBQUUsbUJBQW1CLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIEJhc2VGaWVsZE1hbmFnZXIsXG4gIEZpZWxkRGVjb3JhdG9yRm4sXG4gIGdlbmVyaWNEYXRhRmllbGQsXG4gIElGaWVsZE1ldGFkYXRhLFxufSBmcm9tICcuL2Jhc2UnO1xuXG5leHBvcnQgaW50ZXJmYWNlIElQcmltYXJ5RmllbGRNZXRhZGF0YSBleHRlbmRzIElGaWVsZE1ldGFkYXRhPG51bWJlcj4ge1xuICBzdGVwPzogbnVtYmVyO1xufVxuXG5leHBvcnQgY2xhc3MgUHJpbWFyeUZpZWxkTWFuYWdlclxuICBleHRlbmRzIEJhc2VGaWVsZE1hbmFnZXI8bnVtYmVyPlxuICBpbXBsZW1lbnRzIElQcmltYXJ5RmllbGRNZXRhZGF0YVxue1xuICBwdWJsaWMgc3RlcCA9IDE7XG59XG5cbmV4cG9ydCBjb25zdCBwcmltYXJ5RmllbGQgPSAoXG4gIHVwZGF0ZXM6IElQcmltYXJ5RmllbGRNZXRhZGF0YSA9IHt9XG4pOiBGaWVsZERlY29yYXRvckZuID0+XG4gIGdlbmVyaWNEYXRhRmllbGQodXBkYXRlcywgJ3ByaW1hcnlGaWVsZCcsIFByaW1hcnlGaWVsZE1hbmFnZXIpO1xuIl19

package/esm2020/lib/data/fields/relations.mjs

@@ -0,0 +1,53 @@
+import { BaseFieldManager, genericDataField, } from './base';
+export class ForeignKeyFieldManager extends BaseFieldManager {
+    constructor() {
+        super(...arguments);
+        this.editorType = 'fkselect';
+        this.displayType = 'fkdetails';
+    }
+}
+export class ReverseForeignKeyFieldManager extends BaseFieldManager {
+}
+export class DetailsFieldManager extends BaseFieldManager {
+    fromJson(data, coll) {
+        if (data === null) {
+            return data;
+        }
+        if (data === undefined) {
+            return undefined;
+        }
+        if (this.deserialize) {
+            return this.deserialize(data);
+        }
+        if (this.model) {
+            if (!this.many) {
+                const d = new this.model(coll);
+                d.fromJson(data);
+                return d;
+            }
+            else {
+                const out = [];
+                for (const dt of data) {
+                    const d = new this.model(coll);
+                    d.fromJson(dt);
+                    out.push(d);
+                }
+                return out;
+            }
+        }
+        return data;
+    }
+}
+export class ManyToManyFieldManager extends BaseFieldManager {
+    constructor() {
+        super(...arguments);
+        this.editorType = 'm2mselect';
+        this.displayType = 'm2mdetails';
+    }
+}
+/* eslint-disable max-len */
+export const foreignKeyField = (updates) => genericDataField(updates, 'foreignKeyField', ForeignKeyFieldManager);
+export const reverseForeignKeyField = (updates) => genericDataField(updates, 'reverseForeignKeyField', ReverseForeignKeyFieldManager);
+export const detailsField = (meta = {}) => genericDataField(meta, 'detailsField', DetailsFieldManager);
+export const manyToManyField = (meta) => genericDataField(meta, 'manyToManyField', ManyToManyFieldManager);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/data/fields/stringfields.mjs

@@ -0,0 +1,71 @@
+import { BaseFieldManager, genericDataField, } from './base';
+import { Validators } from '@angular/forms';
+export class CharFieldManager extends BaseFieldManager {
+    constructor(params) {
+        super(params);
+        if (this.choices) {
+            this.editorType = 'select';
+        }
+    }
+    get validators() {
+        const v = super.getValidators();
+        if (this.minLength) {
+            v.push(Validators.minLength(this.minLength));
+        }
+        if (this.maxLength) {
+            v.push(Validators.maxLength(this.maxLength));
+        }
+        if (this.pattern) {
+            v.push(Validators.pattern(this.pattern));
+        }
+        // TODO: add choices validator ??
+        return v;
+    }
+    fromJson(data) {
+        if (data === undefined) {
+            return this.getDefaultValue();
+        }
+        if (data === null) {
+            return this.getDefaultValue();
+        }
+        if (typeof data === 'string') {
+            return data;
+        }
+        return `${data}`;
+    }
+}
+export class EmailFieldManager extends CharFieldManager {
+    constructor(params) {
+        super(params);
+        this.validate = true;
+        this.editorType = 'input.email';
+        if (this.validate === undefined) {
+            this.validate = true;
+        }
+    }
+    get validators() {
+        const v = super.getValidators();
+        if (this.validate) {
+            v.push(Validators.email);
+        }
+        return v;
+    }
+}
+export class TextFieldManager extends CharFieldManager {
+    constructor() {
+        super(...arguments);
+        this.editorType = 'textarea';
+    }
+}
+export class PasswordFieldManager extends CharFieldManager {
+    constructor() {
+        super(...arguments);
+        this.editorType = 'input.password';
+    }
+}
+/* eslint-disable max-len */
+export const charField = (updates = {}) => genericDataField(updates, 'charField', CharFieldManager);
+export const emailField = (updates = {}) => genericDataField(updates, 'emailField', EmailFieldManager);
+export const textField = (updates = {}) => genericDataField(updates, 'textField', TextFieldManager);
+export const passwordField = (updates = {}) => genericDataField(updates, 'passwordField', PasswordFieldManager);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/dispedit/choice.pipe.mjs

@@ -0,0 +1,39 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ChoicePipe {
+    transform(value, field, mode = 'desc') {
+        if (!value) {
+            return '-';
+        }
+        const fvalue = value[field];
+        if (mode === 'code') {
+            return `${fvalue}`;
+        }
+        const manager = value.FM(field);
+        const choices = manager.choices;
+        if (!choices) {
+            return `${fvalue}`;
+        }
+        for (const ch of choices) {
+            if (ch.value === fvalue) {
+                if (mode === 'desc') {
+                    return ch.desc;
+                }
+                else {
+                    return `[${fvalue}] ${ch.desc}`;
+                }
+            }
+        }
+        return `[${fvalue}] ??`;
+    }
+}
+ChoicePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.9", ngImport: i0, type: ChoicePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ChoicePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "14.2.9", ngImport: i0, type: ChoicePipe, isStandalone: true, name: "choice" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.9", ngImport: i0, type: ChoicePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'choice',
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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