@luftborn/custom-elements 2.1.2 → 2.3.0

package/src/elements/SEPersonalNumberElement/SEPersonalNumberElement.ts

@@ -0,0 +1,73 @@
+import CustomElement from '../../framework/custom-element.decorator';
+import { CustomInputElement } from '../../framework/CustomInputElement';
+import { CustomElementEventArgs } from '../../framework/CustomEvents';
+import SEPersonalNumberValidator from '../../framework/Validation/Validators/SEPersonalNumber';
+
+@CustomElement({
+	selector: 'se-personal-number-element',
+	template: `
+        <div class="wrapper">
+            <input type="text" id='se-personal-number-field' placeholder='(YY)YYMMDD-SSSS'/>
+        </div>`,
+	style: `
+        :host{
+            width:100%;
+        }
+        .wrapper{
+            display:flex;
+        }
+        input{
+            box-sizing: border-box;
+            width: 100% !important;
+            border: none;
+            background-color: #f1f4ff;
+            margin: 2px;
+            resize: none;
+        }`,
+	useShadow: true,
+})
+export class SEPersonalNumberElement extends CustomInputElement {
+	text: HTMLInputElement;
+	validator: SEPersonalNumberValidator = new SEPersonalNumberValidator();
+
+	constructor() {
+		super();
+	}
+
+	get value(): string {
+		return `${this.text.value}`;
+	}
+
+	set value(value: string) {
+		this.text.value = value;
+	}
+
+	get valid(): boolean {
+		return this.validator.isSatisfiedBy(this.value, !this.required);
+	}
+
+	connectedCallback(): void {
+		super.connectedCallback();
+	}
+
+	initChildInputs() {
+		this.text = super.getChildInput('#se-personal-number-field');
+		this.text.addEventListener('change', this.change.bind(this));
+		if (this.required) {
+			this.text.setAttribute('required', '');
+		}
+	}
+
+	// events
+	public change($event): void {
+		this.touched = true;
+		this.onChange.emit(new CustomElementEventArgs(this.value, 'change'));
+	}
+
+	public validate(): void {
+		this.valid;
+		this.onValidate.emit(
+			new CustomElementEventArgs(this.value, 'validate'),
+		);
+	}
+}

package/src/framework/Validation/Validators/SECompanyRegistration.ts

@@ -0,0 +1,40 @@
+import IValidation from '../IValidator.interface';
+
+export default class SECompanyRegistrationValidator implements IValidation {
+    private ORG_NR_SE_LUHN_WEIGHTS = [2, 1, 2, 1, 2, 1, 2, 1, 2, 1];
+    private weighted(coefficients: Array<number>) {
+        return (value: number, index: number) => value * coefficients[index];
+    }
+    
+    private sum = (a: number, b: number) => a + b;
+    
+    isSatisfiedBy(input: string, allowEmpty: boolean): boolean {
+        if (allowEmpty && !input) {
+            return true;
+        }
+        
+        return this.orgNrSe(input);
+    }
+    
+    private orgNrSe(value: string) {
+        return this.checkLuhnModulus10(value, this.ORG_NR_SE_LUHN_WEIGHTS);
+    }
+    
+    private checkLuhnModulus10 (testValue: string, luhnWeights: number[]) {
+        const length = luhnWeights.length;
+        const testValue$ = testValue.replace("-", "");
+        if (testValue$.length !== length) {
+            return false;
+        }
+    
+        if (Number.isNaN(parseInt(testValue$, 10))) {
+            return false;
+        }
+    
+        const digits = testValue$.split("").map(Number);
+        const luhnF = (n: number) => (n < length ? n : n - (length - 1));
+        const luhnSum = luhnWeights.map(this.weighted(digits)).map(luhnF).reduce(this.sum);
+        const controlSum = length - (+luhnSum % length);
+        return controlSum % 10 === 0;
+    }   
+}

package/src/framework/Validation/Validators/SEPersonalNumber.ts

@@ -0,0 +1,80 @@
+import IValidation from '../IValidator.interface';
+
+export default class SEPersonalNumberValidator implements IValidation {
+    private regex: RegExp = new RegExp(
+        '^(\d{2}){0,1}(\d{2})(\d{2})(\d{2})([\+\-]?)((?!000)\d{3})(\d)$'
+    );
+
+
+    isSatisfiedBy(input: string, allowEmpty: boolean = true): boolean {
+        if (allowEmpty && !input) {
+            return true;
+        }
+
+        const matches = this.regex.exec(input);
+        if (!matches || matches.length < 7) {
+            return false;
+        }
+
+        const groups = matches;
+        const decade = groups[2];
+        let century;
+
+        if (groups[1]) {
+            century = groups[1];
+        } else {
+            let born = new Date().getFullYear() - parseInt(decade, 10);
+            if (groups[5] && groups[5] === '+') {
+                born -= 100;
+            }
+
+            century = born.toString().substring(0, 2);
+        }
+
+        // Create date time object.
+        let day = parseInt(groups[4], 10);
+        const isCoordinationNumber = day > 60;
+        day = isCoordinationNumber ? day - 60 : day;
+
+        const realDay = day;
+        const year = decade;
+        const fullYear = century + decade;
+        const month = groups[3];
+        const numbers = groups[6] + groups[7];
+        const controlNumber = groups[7];
+
+        // Try parse date-time to make sure it's actually a real date.
+        if (!Date.parse(`${fullYear}-${month}-${realDay}`)) {
+            return false;
+        }
+
+        if (this.luhn(`${year}${month}${day}${groups[6]}`) !== parseInt(controlNumber, 10)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    private luhn(value: string): number {
+        // Luhm algorithm doubles every other number in the value.
+        // To get the correct checksum digit we aught to append a 0 on the sequence.
+        // If the result becomes a two digit number, subtract 9 from the value.
+        // If the total sum is not a 0, the last checksum value should be subtracted from 10.
+        // The resulting value is the check value that we use as control number.
+
+        // The value passed is a string, so we aught to get the actual integer value from each char (i.e., subtract '0' which is 48).
+        const t: number[] = value.split('').map((d) => parseInt(d, 10));
+        let sum = 0;
+        let temp;
+        for (let i = 0; i < t.length; i++) {
+            temp = t[i];
+            temp *= 2 - (i % 2);
+            if (temp > 9) {
+                temp -= 9;
+            }
+            sum += temp;
+        }
+
+        return Math.ceil(sum / 10.0) * 10 - sum;
+    }
+}