fogui-common 0.0.1

package/src/types/base/AttributeType.ts

@@ -0,0 +1,83 @@
+export enum ParseAndValidationCriticality {
+  Ok = 0,
+  Silly,
+  Debug,
+  Info,
+  Warn,
+  Error,
+}
+export type ParseAndValidationResult = {
+  criticality: ParseAndValidationCriticality
+  messages: ParseAndValidationMessage[]
+  subValidationResults?: {[key:string]:ParseAndValidationResult}
+}
+export type ParseAndValidationMessage = {
+  criticality: ParseAndValidationCriticality
+  message: string
+}
+
+export type AttributeTypeOptions<InternalType> = {
+  defaultValue?: InternalType
+  allowNull?: boolean
+  extensionConfigurations?: ExtensionConfiguration[]
+}
+
+export type parseResult<T>= {value: T|undefined, deepResult: ParseAndValidationResult}
+
+export interface ExtensionConfiguration {
+  extensionName: string
+}
+
+let globalExtensionConfigurations: Record<string, Record<string, ExtensionConfiguration>> = {}
+
+export function registerGlobalExtensionConfiguration(typeName: string, config: ExtensionConfiguration) {
+    if(!globalExtensionConfigurations[typeName]){
+        globalExtensionConfigurations[typeName] = {}
+    }
+    globalExtensionConfigurations[typeName][config.extensionName] = config
+}
+
+export class AttributeType<InternalType, ExternalType = string> {
+    value?: InternalType
+    extensionsConfigurations: Record<string, ExtensionConfiguration> = {}
+    get defaultValue(): InternalType | undefined {
+        return this._defaultValue
+    }
+    _defaultValue?: InternalType | undefined
+    allowNull?: boolean = true
+    constructor(options?: AttributeTypeOptions<InternalType>) {
+        options = options || {}
+        this._defaultValue = options.defaultValue
+        this.allowNull = options.allowNull !== undefined ? options.allowNull : true
+        if (options.extensionConfigurations) {
+            for (const extConfig of options.extensionConfigurations) {
+                this.extensionsConfigurations[extConfig.extensionName] = extConfig
+            }
+        }
+    }
+    parse(value: ExternalType): parseResult<InternalType>  {
+        throw new Error("Method not implemented.");
+    }
+    format(value: InternalType): ExternalType {
+        throw new Error("Method not implemented.");
+    }
+    async validate(value: InternalType, level: ParseAndValidationCriticality = ParseAndValidationCriticality.Info): Promise<ParseAndValidationResult> {
+        let validateionObject:ParseAndValidationResult = {criticality:ParseAndValidationCriticality.Ok, messages:[]}
+        if(!value && this.allowNull===false)
+            validateionObject.messages.push({criticality:ParseAndValidationCriticality.Error, message:"Feld darf nicht leer sein."})
+        return validateionObject
+    }
+    getExtensionConfiguration(extensionName: string): ExtensionConfiguration | undefined {
+        let obj = this as AttributeType<any, any>
+        while(obj){
+          if(obj.extensionsConfigurations && obj.extensionsConfigurations[extensionName]){
+            return obj.extensionsConfigurations[extensionName]
+          }
+          if( globalExtensionConfigurations[obj.constructor.name] && globalExtensionConfigurations[obj.constructor.name][extensionName]){
+            return globalExtensionConfigurations[obj.constructor.name][extensionName]
+          }
+          obj = Object.getPrototypeOf(obj)
+        }
+        return undefined
+    }
+}

package/src/types/base/BooleanType.spec.ts

@@ -0,0 +1,48 @@
+import { expect } from "chai";
+import { BooleanType } from "./BooleanType.js";
+
+describe("BooleanType", () => {
+    let boolType: BooleanType;
+
+    beforeEach(() => {
+        boolType = new BooleanType();
+    });
+
+    describe("parse", () => {
+        it("should return true for truthy values", () => {
+            const truthy = ["true", "1", "yes", "on", "x"];
+            truthy.forEach(val => {
+                expect(boolType.parse(val).value).to.be.true;
+                expect(boolType.parse(val.toUpperCase()).value).to.be.true;
+                expect(boolType.parse(val.charAt(0).toUpperCase() + val.slice(1)).value).to.be.true;
+            });
+        });
+
+        it("should return false for falsy values", () => {
+            const falsy = ["false", "0", "no", "off", "", "random"];
+            falsy.forEach(val => {
+                expect(boolType.parse(val).value).to.be.false;
+            });
+        });
+
+        it("should return defaultValue for undefined or null", () => {
+            boolType._defaultValue = true;
+            //expect(boolType.parse(undefined)).to.equal(true);
+            expect(boolType.parse(null as any).value).to.equal(true);
+
+            boolType._defaultValue = false;
+            //expect(boolType.parse(undefined)).to.equal(false);
+            expect(boolType.parse(null as any).value).to.equal(false);
+        });
+    });
+
+    describe("format", () => {
+        it("should format true as 'true'", () => {
+            expect(boolType.format(true)).to.equal("true");
+        });
+
+        it("should format false as 'false'", () => {
+            expect(boolType.format(false)).to.equal("false");
+        });
+    });
+});

package/src/types/base/BooleanType.ts

@@ -0,0 +1,28 @@
+import { AttributeType, AttributeTypeOptions, ParseAndValidationCriticality, parseResult } from "./AttributeType.js";
+
+export type BooleanTypeOptions = AttributeTypeOptions<boolean> & {
+    truthyValues?: string[]
+} 
+
+export class BooleanType extends AttributeType<boolean> {
+    truthyValues = ["true", "1", "yes", "on", "x"]
+    constructor(options?: BooleanTypeOptions) {
+        options = options || {}
+        super(options)
+        if (options.truthyValues) {
+            this.truthyValues = options.truthyValues
+        }
+    }
+    parse(value: string): parseResult<boolean> {
+        if (value === undefined || value === null) {
+            return {value: this.defaultValue, deepResult: { criticality: ParseAndValidationCriticality.Info, messages: [{criticality: ParseAndValidationCriticality.Info, message:'No value given using default Value!'}] }}
+        }
+        else if (this.truthyValues.includes(value.toLowerCase())) {
+            return {value: true, deepResult: { criticality: ParseAndValidationCriticality.Ok, messages: [] } }
+        }
+        return {value: false, deepResult: { criticality: ParseAndValidationCriticality.Ok, messages: [] } }
+    }
+    format(value: boolean): string {
+        return value ? "true" : "false";
+    }
+}

package/src/types/base/NumberType.spec.ts

@@ -0,0 +1,86 @@
+import { expect } from "chai";
+import { NumberType } from "./NumberType.js";
+import { ParseAndValidationCriticality } from "./AttributeType.js";
+
+describe("NumberType", () => {
+    let numberType: NumberType;
+
+    beforeEach(() => {
+        numberType = new NumberType();
+        // Optionally set a default value for testing
+        numberType._defaultValue = 42;
+    });
+
+    describe("parse", () => {
+        it("should parse a valid number string", () => {
+            expect(numberType.parse("123.45").value).to.equal(123.45);
+        });
+
+        it("should parse a negative number string", () => {
+            expect(numberType.parse("-99.99").value).to.equal(-99.99);
+        });
+
+        it("should return defaultValue for invalid number string", () => {
+            expect(numberType.parse("abc").value).to.equal(42);
+        });
+
+        it("should return defaultValue for empty string", () => {
+            expect(numberType.parse("").value).to.equal(42);
+        });
+
+        it("should parse zero", () => {
+            expect(numberType.parse("0").value).to.equal(0);
+        });
+
+        it("should parse string with leading/trailing spaces", () => {
+            expect(numberType.parse("  77.7 ").value).to.equal(77.7);
+        });
+    });
+
+    describe("format", () => {
+        it("should format a number to string", () => {
+            expect(numberType.format(123.45)).to.equal("123.45");
+        });
+
+        it("should format zero", () => {
+            expect(numberType.format(0)).to.equal("0");
+        });
+
+        it("should format a negative number", () => {
+            expect(numberType.format(-99.99)).to.equal("-99.99");
+        });
+    });
+    describe("validate", () => {
+        it("should validate a valid number", async () => {
+            const result = await numberType.validate(123.45);
+            expect(result.criticality).to.equal(0); // Assuming 0 is Ok
+        });
+
+        it("should invalidate NaN", async () => {
+            const result = await numberType.validate(NaN);
+            expect(result.criticality).to.equal(ParseAndValidationCriticality.Error);
+            expect(result.messages).to.deep.include({ criticality: ParseAndValidationCriticality.Error, message: "Not a number" });
+        });
+
+        it("should invalidate number less than min", async () => {
+            numberType.min = 10;
+            const result = await numberType.validate(5);
+            expect(result.criticality).to.equal(ParseAndValidationCriticality.Error); 
+            expect(result.messages).to.deep.include({ criticality: ParseAndValidationCriticality.Error, message: "Value is less than minimum 10" });
+        });
+
+        it("should invalidate number greater than max", async () => {
+            numberType.max = 100;
+            const result = await numberType.validate(150);
+            expect(result.criticality).to.equal(ParseAndValidationCriticality.Error); 
+            expect(result.messages).to.deep.include({ criticality: ParseAndValidationCriticality.Error, message: "Value is greater than maximum 100" });
+        });
+
+        it("should validate number within min and max", async () => {
+            numberType.min = 10;
+            numberType.max = 100;
+            const result = await numberType.validate(50);
+            expect(result.criticality).to.equal(0); // Assuming 0 is Ok
+        });
+    });
+});

package/src/types/base/NumberType.ts

@@ -0,0 +1,43 @@
+import { AttributeType, AttributeTypeOptions, ParseAndValidationCriticality, ParseAndValidationResult, parseResult } from "./AttributeType.js";
+
+export type NumberTypeOptions = {
+    max?: number,
+    min?: number
+} & AttributeTypeOptions<number>
+
+export class NumberType extends AttributeType<number> {
+    max: number 
+    min: number 
+    constructor(options?: NumberTypeOptions) {
+        options = options || {}
+        super(options)
+        this.max = options.max || Infinity
+        this.min = options.min || -Infinity
+    }
+    parse(value: string): parseResult<number> {
+        const number = parseFloat(value)
+        if (isNaN(number)) {
+            return {value: this.defaultValue, deepResult: { criticality: ParseAndValidationCriticality.Warn, messages: [{ criticality: ParseAndValidationCriticality.Warn, message: "Not a number useing default Value" }] }}
+        }
+        return {value: number, deepResult: { criticality: ParseAndValidationCriticality.Ok, messages: [] } }
+    }
+    validate(value: number, level?: ParseAndValidationCriticality): Promise<ParseAndValidationResult> {
+        let validationObject: ParseAndValidationResult = { criticality: ParseAndValidationCriticality.Ok, messages: [] }
+        if (isNaN(value)) {
+            validationObject.criticality = ParseAndValidationCriticality.Error
+            validationObject.messages.push({ criticality: ParseAndValidationCriticality.Error, message: "Not a number" })
+        }
+        if (value < this.min) {
+            validationObject.criticality = ParseAndValidationCriticality.Error
+            validationObject.messages.push({ criticality: ParseAndValidationCriticality.Error, message: `Value is less than minimum ${this.min}` })
+        }
+        if (value > this.max) {
+            validationObject.criticality = ParseAndValidationCriticality.Error
+            validationObject.messages.push({ criticality: ParseAndValidationCriticality.Error, message: `Value is greater than maximum ${this.max}` })
+        }
+        return Promise.resolve(validationObject)
+    }
+    format(value: number): string {
+        return value.toString()
+    }
+}

package/src/types/base/StringArrayType.ts

@@ -0,0 +1,6 @@
+import { ArrayType } from "./ArrayType.js";
+import { StringType } from "./StringType.js";
+
+export class StringArrayType extends ArrayType<string, string>{
+    type = new StringType()
+}

package/src/types/base/StringType.spec.ts

@@ -0,0 +1,34 @@
+import { expect } from "chai";
+import { StringType } from "./StringType.js";
+
+describe("StringType", () => {
+    let stringType: StringType;
+
+    beforeEach(() => {
+        stringType = new StringType({ defaultValue: "default" });
+    });
+
+    describe("parse", () => {
+        it("should return the value if it is not null or undefined", () => {
+            expect(stringType.parse("hello").value).to.equal("hello");
+        });
+
+        it("should return defaultValue if value is null", () => {
+            expect(stringType.parse(null as any).value).to.equal("default");
+        });
+
+        it("should return defaultValue if value is undefined", () => {
+            expect(stringType.parse(undefined as any).value).to.equal("default");
+        });
+    });
+
+    describe("format", () => {
+        it("should return the value as is", () => {
+            expect(stringType.format("world")).to.equal("world");
+        });
+
+        it("should return empty string as is", () => {
+            expect(stringType.format("")).to.equal("");
+        });
+    });
+});

package/src/types/base/StringType.ts

@@ -0,0 +1,69 @@
+import { AttributeType, AttributeTypeOptions, ParseAndValidationCriticality, ParseAndValidationResult, parseResult } from "./AttributeType.js";
+
+export type StringTypeOptions = AttributeTypeOptions<string> & {
+  maxLength?: number
+  minLength?: number
+  matchPattern?: RegExp
+  matchPatternMessage?: string
+  parsePattern?: RegExp
+  parseReplacement?: string
+  parsePatternMessage?: string
+  formatPattern?: RegExp
+  formatReplacement?: string
+}
+
+export class StringType<ExternalType extends string = string> extends AttributeType<string, ExternalType> {
+    maxLength: number
+    minLength: number
+    parsePattern: RegExp | null
+    parseReplacement: string | null
+    parsePatternMessage: string 
+    matchPattern: RegExp | null
+    matchPatternMessage: string | null
+    formatPattern: RegExp | null 
+    formatReplacement: string | null 
+    constructor(options?: StringTypeOptions) {
+        options = options || {}
+        super(options)
+        this.maxLength = options.maxLength || 255
+        this.minLength = options.minLength || 0
+        this.parsePattern = options.parsePattern || null
+        this.parseReplacement = options.parseReplacement || null
+        this.parsePatternMessage = options.parsePatternMessage || `Parse pattern not matched: "${this.parsePattern}"`
+        this.matchPattern = options.matchPattern ||  null
+        this.matchPatternMessage = options.matchPatternMessage || null
+        this.formatPattern = options.formatPattern || null
+        this.formatReplacement = options.formatReplacement || null
+    }
+    parse(value: ExternalType): parseResult<string> {
+        if(!value) return {value: this.defaultValue, deepResult: { criticality: ParseAndValidationCriticality.Info, messages: [{criticality: ParseAndValidationCriticality.Info, message:'No value given using default Value!'}] }}
+        if(this.parsePattern && this.parseReplacement){
+            if(!this.parsePattern.test(value)) throw new Error(this.parsePatternMessage)
+            value = value.replace(this.parsePattern, this.parseReplacement) as ExternalType
+        }
+        return {value, deepResult: { criticality: ParseAndValidationCriticality.Ok, messages: [] } } 
+    }
+    async validate(value: string, level?: ParseAndValidationCriticality): Promise<ParseAndValidationResult> {
+        console.log("Validating string:", value)
+        let validationObject = await super.validate(value, level)
+        if(value && this.matchPattern && !this.matchPattern.test(value)){
+            validationObject.messages.push({criticality:ParseAndValidationCriticality.Error, message: this.matchPatternMessage || `Validierungsmuster nicht erfüllt: "${this.matchPattern}"`})
+            validationObject.criticality=Math.max(validationObject.criticality,ParseAndValidationCriticality.Error)
+        }
+        if(value && value.length < this.minLength){
+            validationObject.messages.push({criticality:ParseAndValidationCriticality.Error, message: `Es müssen mindesten ${this.minLength} Zeichen eingegeben werden.`})
+            validationObject.criticality=Math.max(validationObject.criticality,ParseAndValidationCriticality.Error)
+        }
+        if(value && value.length > this.maxLength){
+            validationObject.messages.push({criticality:ParseAndValidationCriticality.Error, message: `Es dürfen maximal ${this.maxLength} Zeichen eingegeben werden.`})
+            validationObject.criticality=Math.max(validationObject.criticality,ParseAndValidationCriticality.Error)
+        }
+        return validationObject
+    }
+    format(value: string): ExternalType {
+        if(this.formatPattern && this.formatReplacement){
+            value = value.replace(this.formatPattern, this.formatReplacement)
+        }
+        return value as ExternalType;
+    }
+}

package/src/util/InferType.ts

@@ -0,0 +1,27 @@
+import { Model } from "../model/base/Model.js";
+import { ArrayType } from "../types/base/ArrayType.js";
+import { AttributeType } from "../types/base/AttributeType.js";
+
+
+type RequriedKeys<T> = {
+    [K in keyof T]: T[K] extends { required: true } ? K : never;
+}[keyof T];
+
+type OptionalKeys<T> = {
+    [K in keyof T]: T[K] extends { required: true } ? never : K;
+}[keyof T];
+
+type PartialPartial<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K> extends
+    infer O ? { [P in keyof O]: O[P] } : never;
+
+export type InferType<T> = T extends Model
+    ? 
+          PartialPartial<{[K in keyof T["properties"]]: InferType<T["properties"][K]["type"]>},
+           OptionalKeys<T["properties"]>>
+    
+    : T extends ArrayType<infer U, infer V>
+    ? InferType<T["type"]>[]
+    : 
+    T extends AttributeType<infer U>
+    ? U
+    : never;

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "esnext",
+    "moduleResolution": "node",
+    "noEmitOnError": true,
+    "lib": ["es2022", "dom"],
+    "strict": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "experimentalDecorators": true,
+    "importHelpers": true,
+    "declaration": true,
+    "outDir": "dist",
+    "sourceMap": true,
+    "inlineSources": true,
+    "rootDir": "./src/",
+    "incremental": true
+  },
+  "include": ["src/**/*.ts"]
+}