@quatrain/core 1.1.24 → 1.1.28

package/src/properties/NumberProperty.test.ts

@@ -0,0 +1,38 @@
+import { NumberProperty } from './NumberProperty'
+
+describe('Number Property accept all numbers', () => {
+   const prop = new NumberProperty({ name: 'toto' })
+   test('allow positive number', () => expect(prop.set(10).val()).toBe(10))
+   test('allow zero number', () => expect(prop.set(0).val()).toBe(0))
+   test('allow negative number', () => expect(prop.set(-10).val()).toBe(-10))
+})
+
+describe('Number Property can restrict signed numbers', () => {
+   const prop = new NumberProperty({
+      name: 'toto',
+      sign: NumberProperty.TYPE_UNSIGNED,
+   })
+   test('only allow positive or zero number', () =>
+      expect(() => prop.set(-1)).toThrow())
+})
+
+describe('Number Property can display prefix or/and suffix', () => {
+   test('display prefix', () =>
+      expect(
+         new NumberProperty({
+            name: 'toto',
+            prefix: 'EUR',
+         })
+            .set(123)
+            .val(NumberProperty.TRANSFORM_FORMATTED)
+      ).toBe('EUR 123'))
+   test('display suffix', () =>
+      expect(
+         new NumberProperty({
+            name: 'toto',
+            suffix: '€',
+         })
+            .set(123)
+            .val(NumberProperty.TRANSFORM_FORMATTED)
+      ).toBe('123 €'))
+})

package/src/properties/NumberProperty.ts

@@ -0,0 +1,110 @@
+import { BaseProperty, BasePropertyType } from './BaseProperty'
+
+export type NumberSign =
+   | typeof NumberProperty.TYPE_SIGNED
+   | typeof NumberProperty.TYPE_UNSIGNED
+
+export type NumberType =
+   | typeof NumberProperty.TYPE_INTEGER
+   | typeof NumberProperty.TYPE_FLOAT
+
+export interface NumberPropertyType extends BasePropertyType {
+   minVal?: number
+   maxVal?: number
+   sign?: NumberSign
+   type?: NumberType
+   prefix?: string
+   suffix?: string
+   precision?: number
+}
+
+export class NumberProperty extends BaseProperty {
+   static TYPE = 'number'
+   static TYPE_SIGNED = 'signed'
+   static TYPE_UNSIGNED = 'unsigned'
+
+   static TYPE_INTEGER = 'integer'
+   static TYPE_FLOAT = 'float'
+
+   static SEPARATOR = ' '
+
+   static TRANSFORM_FORMATTED = 'formatted'
+
+   protected _minVal: number | undefined = undefined
+   protected _maxVal: number | undefined = undefined
+   protected _type: NumberType = NumberProperty.TYPE_INTEGER
+   protected _sign: NumberSign = NumberProperty.TYPE_SIGNED
+   protected _prefix: string = ''
+   protected _suffix: string = ''
+   protected _precision: number = 0
+
+   declare protected _value: number | undefined
+
+   constructor(config: NumberPropertyType) {
+      super(config)
+      this.minVal = config.minVal || undefined
+      this.maxVal = config.maxVal || undefined
+      this._prefix = config.prefix
+         ? `${config.prefix}${NumberProperty.SEPARATOR}`
+         : ''
+      this._suffix = config.suffix
+         ? `${NumberProperty.SEPARATOR}${config.suffix}`
+         : ''
+      if (config.type) {
+         this._type = config.type
+      }
+      if (config.sign) {
+         this._sign = config.sign
+      }
+   }
+
+   set(value: number, setChanged = true) {
+      if (this._sign === NumberProperty.TYPE_UNSIGNED && value < 0) {
+         throw new Error(`Value must be unsigned`)
+      }
+
+      if (this._minVal && value < this._minVal) {
+         throw new Error(`Value is below ${this._minVal}`)
+      }
+
+      if (this._maxVal && value > this._maxVal) {
+         throw new Error(`Value is above ${this._maxVal}`)
+      }
+
+      if (this._type === NumberProperty.TYPE_INTEGER) {
+         value = Math.floor(value)
+      }
+
+      return super.set(value, setChanged)
+   }
+
+   val(transform: string | undefined = undefined) {
+      switch (transform) {
+         case NumberProperty.TRANSFORM_FORMATTED:
+            return `${this._prefix}${this._value}${this._suffix}`
+
+         default:
+            return this._value
+      }
+   }
+
+   set minVal(min: number | undefined) {
+      this._minVal = min
+   }
+
+   get minVal() {
+      return this._minVal
+   }
+
+   set maxVal(max: number | undefined) {
+      this._maxVal = max
+   }
+
+   get maxVal() {
+      return this._maxVal
+   }
+
+   get type() {
+      return this._type
+   }
+}

package/src/properties/ObjectProperty.ts

@@ -0,0 +1,118 @@
+import { DataObject } from '../components/DataObject'
+import { ObjectUri } from '../components/ObjectUri'
+import { BaseProperty, BasePropertyType } from './BaseProperty'
+import { BaseObjectClass } from '../components/types/BaseObjectClass'
+import { Core } from '../Core'
+
+// TODO move in types
+export enum returnAs {
+   AS_OBJECTURIS = 'objectUris',
+   AS_DATAOBJECTS = 'dataObjects',
+   AS_INSTANCES = 'classInstances',
+   AS_IS = 'asIs',
+}
+
+export interface ObjectPropertyType extends BasePropertyType {
+   instanceOf: any //Function | string | Object
+}
+
+export class ObjectProperty extends BaseProperty {
+   static TYPE = 'object'
+   _value: BaseObjectClass | ObjectUri | undefined = undefined
+   _instanceOf: any //Function | string | Object
+
+   constructor(config: ObjectPropertyType) {
+      super(config)
+      this._instanceOf = config.instanceOf
+   }
+
+   get instanceOf() {
+      return this._instanceOf
+   }
+
+   val(transform: string | undefined = undefined) {
+      try {
+         if (typeof this._instanceOf === 'string') {
+            this._instanceOf = Core.getClass(this._instanceOf)
+         }
+
+         if (!this._value) {
+            return this._defaultValue
+         }
+
+         switch (transform) {
+            case returnAs.AS_DATAOBJECTS:
+               if (this._value instanceof DataObject) {
+                  Core.debug(`Returning already existing dataObject`)
+                  return this._value
+               } else if (this._value instanceof ObjectUri) {
+                  Core.debug(`Converting objectUri -> dataObject`)
+                  return DataObject.factory({
+                     properties: Reflect.get(
+                        this._instanceOf,
+                        'PROPS_DEFINITION'
+                     ),
+                     uri: this._value,
+                  })
+               } else {
+                  Core.debug(`Converting instance -> dataObject`)
+                  return this._value.dataObject
+               }
+            case returnAs.AS_INSTANCES:
+               if (this._value instanceof DataObject) {
+                  Core.debug(`Converting dataObject -> instance`)
+                  return Reflect.construct(this._instanceOf, [this._value])
+               } else if (this._value instanceof ObjectUri) {
+                  Core.debug(`Converting objectUri -> dataObject -> instance`)
+                  const dao = DataObject.factory({
+                     properties: Reflect.get(
+                        this._instanceOf,
+                        'PROPS_DEFINITION'
+                     ),
+                     uri: this._value,
+                  })
+                  return Reflect.construct(this._instanceOf, [dao])
+               } else {
+                  Core.log(`Returning already existing instance`)
+                  return this._value
+               }
+            case returnAs.AS_OBJECTURIS:
+            default:
+               return this._value
+         }
+      } catch (err) {
+         Core.error(
+            `Error in ObjectProperty.val() for property ${this._name}: ${err}`
+         )
+         console.log(err)
+         return undefined
+      }
+   }
+
+   set(value: object, setChanged = true) {
+      if (
+         value! instanceof ObjectUri &&
+         value! instanceof DataObject &&
+         value.constructor.name !== this._instanceOf.constructor.name
+      ) {
+         throw new Error(
+            `value ${JSON.stringify(value)} is not an instance of ${
+               this._instanceOf.constructor.name
+            }`
+         )
+      }
+
+      return super.set(value, setChanged)
+   }
+
+   toJSON() {
+      if (this._value instanceof ObjectUri) {
+         return this._value.toJSON()
+      }
+
+      return this._value &&
+         (this._value.dataObject || this._value instanceof DataObject)
+         ? this._value.dataObject.toReference()
+         : null
+   }
+}

package/src/properties/Property.ts

@@ -0,0 +1,85 @@
+import { DataObjectClass } from '../components/types/DataObjectClass'
+import { BaseProperty } from './BaseProperty'
+import { BooleanProperty, BooleanPropertyType } from './BooleanProperty'
+import { DateTimeProperty, DateTimePropertyType } from './DateTimeProperty'
+import { EnumProperty, EnumPropertyType } from './EnumProperty'
+import { HashProperty, HashPropertyType } from './HashProperty'
+import { StringProperty, StringPropertyType } from './StringProperty'
+import { NumberProperty, NumberPropertyType } from './NumberProperty'
+import { ObjectProperty, ObjectPropertyType } from './ObjectProperty'
+import { CollectionProperty } from './CollectionProperty'
+import { ArrayProperty } from './ArrayProperty'
+import { MapProperty } from './MapProperty'
+import { FileProperty, FilePropertyType } from './FileProperty'
+
+export class Property {
+   static TYPE_ANY = 'any'
+   static TYPE_NUMBER = 'number'
+   static TYPE_STRING = 'string'
+   static TYPE_OBJECT = 'object'
+   static TYPE_ENUM = 'enum'
+   static TYPE_BOOLEAN = 'boolean'
+   static TYPE_HASH = 'hash'
+   static TYPE_DATETIME = 'datetime'
+   static TYPE_ARRAY = 'array'
+   static TYPE_MAP = 'map'
+   static TYPE_FILE = 'file'
+
+   static factory(
+      params: ObjectPropertyType &
+         StringPropertyType &
+         NumberPropertyType &
+         EnumPropertyType &
+         BooleanPropertyType &
+         HashPropertyType &
+         DateTimePropertyType &
+         FilePropertyType,
+      parent: DataObjectClass<any>
+   ) {
+      params.parent = parent
+      switch (params.type) {
+         case BaseProperty.TYPE:
+            return new BaseProperty(params)
+
+         case StringProperty.TYPE:
+            return new StringProperty(params)
+
+         case NumberProperty.TYPE:
+            return new NumberProperty(params)
+
+         case ObjectProperty.TYPE:
+            return new ObjectProperty(params)
+
+         case EnumProperty.TYPE:
+            return new EnumProperty(params)
+
+         case BooleanProperty.TYPE:
+            return new BooleanProperty(params)
+
+         case HashProperty.TYPE:
+            return new HashProperty(params)
+
+         case DateTimeProperty.TYPE:
+            return new DateTimeProperty(params)
+
+         case CollectionProperty.TYPE:
+            if (!('instanceOf' in params)) {
+               throw new Error('Missing property instanceOf!')
+            }
+
+            return new CollectionProperty(params as any)
+
+         case ArrayProperty.TYPE:
+            return new ArrayProperty(params)
+
+         case MapProperty.TYPE:
+            return new MapProperty(params)
+
+         case FileProperty.TYPE:
+            return new FileProperty(params)
+
+         default:
+            throw new Error(`Unknown property type ${params.type}`)
+      }
+   }
+}

package/src/properties/StringProperty.test.ts

@@ -0,0 +1,46 @@
+import { StringProperty } from './StringProperty'
+
+describe('String Property without digits', () => {
+   const prop = new StringProperty({ name: 'toto', allowDigits: false })
+   test('allow digits is not set', () =>
+      expect(prop.allows).not.toContain(StringProperty.ALLOW_DIGITS))
+   test('no digits allowed', () => expect(() => prop.set('va1ue')).toThrow())
+})
+
+describe('String Property without spaces', () => {
+   const prop = new StringProperty({ name: 'toto', allowSpaces: false })
+   test('allow spaces is not set', () =>
+      expect(prop.allows).not.toContain(StringProperty.ALLOW_SPACES))
+   test('no space allowed', () => expect(() => prop.set('va1 ue')).toThrow())
+})
+
+describe('String Property without letters', () => {
+   const prop = new StringProperty({ name: 'toto', allowLetters: false })
+   test('allow letters is not set', () =>
+      expect(prop.allows).not.toContain(StringProperty.ALLOW_LETTERS))
+   test('no letters allowed', () => expect(() => prop.set('value')).toThrow())
+})
+
+describe('String Property with minimal length', () => {
+   const prop = new StringProperty({ name: 'toto', minLength: 6 })
+   test('minlength is set', () => expect(prop.minLength).toBeGreaterThan(0))
+   test('minimum length of 5', () => expect(() => prop.set('value')).toThrow())
+})
+
+describe('String Property with maximal length', () => {
+   const prop = new StringProperty({ name: 'toto', maxLength: 4 })
+   test('maxlength is set', () => expect(prop.maxLength).toBeGreaterThan(0))
+   test('maximum length of 5', () => expect(() => prop.set('value')).toThrow())
+})
+
+describe('String Property provides transformers', () => {
+   const prop = new StringProperty({ name: 'toto' })
+   test('transform to upper case', () =>
+      expect(prop.set('value').get(StringProperty.TRANSFORM_UCASE)).toBe(
+         'VALUE'
+      ))
+   test('transform to lower case', () =>
+      expect(prop.set('VALUE').get(StringProperty.TRANSFORM_LCASE)).toBe(
+         'value'
+      ))
+})

package/src/properties/StringProperty.ts

@@ -0,0 +1,121 @@
+//import { Property } from './Property'
+import { BaseProperty, BasePropertyType } from './BaseProperty'
+
+export interface StringPropertyType extends BasePropertyType {
+   minLength?: number
+   maxLength?: number
+   allowSpaces?: boolean
+   allowDigits?: boolean
+   allowLetters?: boolean
+   allowPattern?: string
+   fullSearch?: boolean
+}
+
+export class StringProperty extends BaseProperty {
+   static TYPE = 'string'
+
+   static TRANSFORM_UCASE = 'upper'
+   static TRANSFORM_LCASE = 'lower'
+
+   static ALLOW_SPACES = 'spaces'
+   static ALLOW_LETTERS = 'letters'
+   static ALLOW_DIGITS = 'digits'
+   static ALLOW_STRINGS = 'strings'
+   static ALLOW_NUMBERS = 'numbers'
+
+   protected _minLength: number = 0
+   protected _maxLength: number = 0
+   protected _fullSearch: boolean = false
+
+   protected declare _value: string | undefined
+
+   /**
+    * Set to false to bypass some rules
+    */
+   protected _rawValue = true
+
+   constructor(config: StringPropertyType) {
+      super(config)
+      this.minLength = config.minLength || 0
+      this.maxLength = config.maxLength || 0
+      this.fullSearch = config.fullSearch || false
+      if (this._enable(config.allowSpaces)) {
+         this._allows.push(StringProperty.ALLOW_SPACES)
+      }
+      if (this._enable(config.allowDigits)) {
+         this._allows.push(StringProperty.ALLOW_DIGITS)
+      }
+      if (this._enable(config.allowLetters)) {
+         this._allows.push(StringProperty.ALLOW_LETTERS)
+      }
+   }
+
+   set(value: any, setChanged = true) {
+      if (this._rawValue && value !== null && value !== undefined) {
+         if (
+            !this._allows.includes(StringProperty.ALLOW_DIGITS) &&
+            /\d/.test(value)
+         ) {
+            throw new Error(`Digits are not allowed in value`)
+         }
+
+         if (
+            !this._allows.includes(StringProperty.ALLOW_SPACES) &&
+            /\s/.test(value)
+         ) {
+            throw new Error(`Spaces are not allowed in value`)
+         }
+
+         if (
+            !this._allows.includes(StringProperty.ALLOW_LETTERS) &&
+            /[a-zA-Z]/.test(value)
+         ) {
+            throw new Error(`Letters are not allowed in value`)
+         }
+
+         if (this._minLength > 0 && value.length < this._minLength) {
+            throw new Error(`Value is too short`)
+         }
+
+         if (this._maxLength > 0 && value.length > this._maxLength) {
+            throw new Error(`${this._name}: value '${value}' is too long`)
+         }
+      }
+      return super.set(value, setChanged)
+   }
+
+   get(transform: string | undefined = undefined) {
+      switch (transform) {
+         case StringProperty.TRANSFORM_LCASE:
+            return this._value && this._value.toLowerCase()
+         case StringProperty.TRANSFORM_UCASE:
+            return this._value && this._value.toUpperCase()
+         default:
+            return this._value
+      }
+   }
+
+   set minLength(min: number) {
+      this._minLength = min >= 0 ? min : 0
+   }
+
+   get minLength() {
+      return this._minLength
+   }
+
+   set maxLength(max: number) {
+      this._maxLength = max >= 0 ? max : 0
+   }
+
+   get maxLength() {
+      return this._maxLength
+   }
+
+   set fullSearch(mode: boolean) {
+      this._fullSearch = mode
+   }
+
+   get fullSearch() {
+      return this._fullSearch
+   }
+}

package/src/properties/index.ts

@@ -0,0 +1,62 @@
+import { Property } from './Property'
+import { BaseProperty, BasePropertyType } from './BaseProperty'
+import { ArrayProperty, ArrayPropertyType } from './ArrayProperty'
+import { NumberProperty, NumberPropertyType } from './NumberProperty'
+import { StringProperty, StringPropertyType } from './StringProperty'
+import { HashProperty, HashPropertyType } from './HashProperty'
+import { EnumProperty, EnumPropertyType } from './EnumProperty'
+import { BooleanProperty, BooleanPropertyType } from './BooleanProperty'
+import { DateTimeProperty, DateTimePropertyType } from './DateTimeProperty'
+import { ObjectProperty, ObjectPropertyType } from './ObjectProperty'
+import { MapProperty, MapPropertyType } from './MapProperty'
+import { FileProperty, FilePropertyType } from './FileProperty'
+import {
+   CollectionProperty,
+   CollectionPropertyType,
+} from './CollectionProperty'
+import { PropertyTypes } from './types/PropertyTypes'
+
+export {
+   Property,
+   BaseProperty,
+   ArrayProperty,
+   NumberProperty,
+   BooleanProperty,
+   DateTimeProperty,
+   EnumProperty,
+   ObjectProperty,
+   StringProperty,
+   HashProperty,
+   MapProperty,
+   FileProperty,
+   CollectionProperty,
+}
+export type {
+   BasePropertyType,
+   ArrayPropertyType,
+   NumberPropertyType,
+   BooleanPropertyType,
+   DateTimePropertyType,
+   EnumPropertyType,
+   ObjectPropertyType,
+   StringPropertyType,
+   HashPropertyType,
+   MapPropertyType,
+   FilePropertyType,
+   CollectionPropertyType,
+}
+
+type BaseType = { type: PropertyTypes }
+
+export type DataObjectProperties = (
+   | (NumberPropertyType & BaseType)
+   | (BooleanPropertyType & BaseType)
+   | (EnumPropertyType & BaseType)
+   | (ObjectPropertyType & BaseType)
+   | (StringPropertyType & BaseType)
+   | (HashPropertyType & BaseType)
+   | (DateTimePropertyType & BaseType)
+   | (ArrayPropertyType & BaseType)
+   | (MapPropertyType & BaseType)
+   | (CollectionPropertyType & BaseType)
+)[]

package/src/properties/types/AbstractPropertyType.ts

@@ -0,0 +1,8 @@
+import { PropertyTypes } from './PropertyTypes'
+
+export interface AbstractPropertyType {
+   name: string
+   id?: string
+   type?: PropertyTypes
+   defaultValue?: any
+}

package/src/properties/types/PropertyClassType.ts

@@ -0,0 +1,11 @@
+import { AbstractPropertyType } from './AbstractPropertyType'
+
+export interface PropertyClassType {
+   id?: string
+   name: string
+   set(value: any, setChanged?: boolean): AbstractPropertyType
+   val(transform?: any): any
+   toJSON(): any
+   clone(): PropertyClassType
+   hasChanged?: boolean
+}

package/src/properties/types/PropertyHTMLType.ts

@@ -0,0 +1,23 @@
+// @see https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/autocomplete
+// @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill
+
+export const OFF = 'off'
+export const NAME = 'name'
+export const GIVEN_NAME = 'given-name'
+export const FAMILY_NAME = 'family-name'
+export const EMAIL = 'email'
+export const PASSWORD = 'password'
+export const BIRTHDAY = 'bday'
+export const GENDER = 'sex'
+export const ORG = 'organization'
+
+export type PropertyHTMLType =
+   | typeof OFF
+   | typeof NAME
+   | typeof GIVEN_NAME
+   | typeof FAMILY_NAME
+   | typeof EMAIL
+   | typeof PASSWORD
+   | typeof BIRTHDAY
+   | typeof GENDER
+   | typeof ORG

package/src/properties/types/PropertyTypes.ts

@@ -0,0 +1,13 @@
+import { Property } from '..'
+
+export type PropertyTypes =
+   | typeof Property.TYPE_STRING
+   | typeof Property.TYPE_NUMBER
+   | typeof Property.TYPE_ENUM
+   | typeof Property.TYPE_BOOLEAN
+   | typeof Property.TYPE_OBJECT
+   | typeof Property.TYPE_DATETIME
+   | typeof Property.TYPE_HASH
+   | typeof Property.TYPE_ARRAY
+
+export type BaseType = { type: PropertyTypes }