@regulaforensics/idv-interfaces 0.1.248-nightly

package/README.md

@@ -0,0 +1,3 @@
+# Interfaces-idv module
+
+Module which exports common types, enums, interfaces

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+export declare class BaseError {
+    errorCode: number | string;
+    errorCodeKey: string;
+    message?: string;
+    underlyingError?: string;
+    underlyingBaseError?: BaseError;
+    domain?: string;
+    module: string;
+    errorEnumName: string;
+    shortDomainCode: string;
+    constructor({ errorCode, errorCodeKey, message, underlyingError, underlyingBaseError, domain, module, errorEnumName, shortDomainCode, }: {
+        errorCode: number | string;
+        errorCodeKey: string;
+        module: string;
+        message?: string;
+        underlyingError?: string;
+        underlyingBaseError?: BaseError;
+        domain?: string;
+        errorEnumName: string;
+        shortDomainCode: string;
+    });
+    static getErrorKey<T extends Record<string, any>>(errorCode: number | string, errorEnum: T): string;
+    get lastUnderlyingError(): string | undefined;
+    toObject(): Record<string, any>;
+    get shortChain(): string;
+    get fullChain(): string;
+}
+
+export declare abstract class BaseModule<TModuleProps = unknown, TModulesConfig = unknown> extends HTMLElement {
+    abstract props: IdvModuleProps<TModuleProps, TModulesConfig> | null;
+    abstract setProps(config: IdvModuleProps<TModuleProps, TModulesConfig>): void;
+}
+
+export declare function cleanObjectFromUndefined(obj: Record<string, unknown>): Record<string, unknown>;
+
+export declare type IdvModuleProps<TModuleProps, TModulesConfig> = {
+    isProcessing?: (isProcessing: boolean) => void;
+    moduleProps: TModuleProps;
+    modulesConfig?: TModulesConfig;
+    perform: (data: any) => void;
+    idvEventListener: (module: string, data: any) => void;
+};
+
+export declare interface IdvModuleStaticMethods {
+    displayName: string;
+    isReady(): boolean;
+    getSupportedTemplates(): string[];
+    initialize(modulesConfig: Record<string, unknown>): void;
+    deinitialize(): void;
+    getIdentifier(): string;
+}
+
+export declare type ModuleClass<TModuleProps = unknown, TModulesConfig = unknown> = IdvModuleStaticMethods & (new (...args: any[]) => BaseModule<TModuleProps, TModulesConfig>);
+
+export declare function parseClientJSON<T>(json: T): T;
+
+export declare function registerModule<TModuleProps = unknown, TModulesConfig = unknown>(name: string, ModuleClass: ModuleClass<TModuleProps, TModulesConfig>): void;
+
+export { }

package/dist/main.js

@@ -0,0 +1,102 @@
+var l = Object.defineProperty;
+var m = Object.getOwnPropertySymbols;
+var u = Object.prototype.hasOwnProperty, E = Object.prototype.propertyIsEnumerable;
+var y = (r, e, i) => e in r ? l(r, e, { enumerable: !0, configurable: !0, writable: !0, value: i }) : r[e] = i, s = (r, e) => {
+  for (var i in e || (e = {}))
+    u.call(e, i) && y(r, i, e[i]);
+  if (m)
+    for (var i of m(e))
+      E.call(e, i) && y(r, i, e[i]);
+  return r;
+};
+class o {
+  constructor({
+    errorCode: e,
+    errorCodeKey: i,
+    message: t,
+    underlyingError: n,
+    underlyingBaseError: g,
+    domain: f,
+    module: c,
+    errorEnumName: a,
+    shortDomainCode: p
+  }) {
+    this.errorCode = e, this.errorCodeKey = i, this.message = t, this.underlyingError = n, this.underlyingBaseError = g, this.module = c, this.domain = f, this.errorEnumName = a, this.shortDomainCode = p;
+  }
+  static getErrorKey(e, i) {
+    const t = Object.keys(i).find((n) => i[n] === e);
+    if (!t)
+      throw new Error(`Invalid errorCode: ${e} in enum`);
+    return t;
+  }
+  get lastUnderlyingError() {
+    let e = this.underlyingBaseError;
+    for (; (e == null ? void 0 : e.underlyingBaseError) instanceof o; )
+      e = e.underlyingBaseError;
+    return e == null ? void 0 : e.underlyingError;
+  }
+  toObject() {
+    const e = {
+      errorCode: this.errorCode,
+      errorCodeKey: this.errorCodeKey,
+      errorEnumName: this.errorEnumName,
+      message: this.message,
+      module: this.module,
+      underlyingError: this.underlyingError,
+      lastUnderlineError: this.lastUnderlyingError
+    };
+    return this.underlyingBaseError && this.underlyingBaseError instanceof o && (e.underlyingBaseError = this.underlyingBaseError.toObject()), e;
+  }
+  get shortChain() {
+    let e = `${this.shortDomainCode}:${this.errorCode}${this.underlyingError ? "-" + this.underlyingError : ""}`;
+    return this.underlyingBaseError instanceof o && (e += `-${this.underlyingBaseError.shortChain}`), e;
+  }
+  get fullChain() {
+    let e = `${this.module}.${this.domain}:${this.errorCodeKey}${this.underlyingError ? "-" + this.underlyingError : ""}`;
+    return this.underlyingBaseError instanceof o && (e += `-${this.underlyingBaseError.fullChain}`), e;
+  }
+}
+class b extends HTMLElement {
+}
+function w(r, e) {
+  if (e.displayName ? console.log(`Register module: ${e.displayName}`) : console.error('Missed "displayName" when register module'), e.getSupportedTemplates && typeof e.getSupportedTemplates == "function") {
+    const i = e.getSupportedTemplates();
+    console.log(`${e == null ? void 0 : e.displayName} supported templates: ${i.join(", ")}`);
+  } else
+    console.error('Missed "getSupportedTemplates" method when register module');
+  if (e.initialize && typeof e.initialize == "function" || console.error(`${e == null ? void 0 : e.displayName} "initialize" method was not implemented`), e.deinitialize && typeof e.deinitialize == "function" || console.error(`${e == null ? void 0 : e.displayName} "deinitialize" method was not implemented`), e.isReady && typeof e.isReady == "function" || console.error(`${e == null ? void 0 : e.displayName} "isReady" method was not implemented`), e.getIdentifier && typeof e.getIdentifier == "function") {
+    const i = e.getIdentifier();
+    console.log(`Module id: ${i}`);
+  } else
+    console.error('Missed "getIdentifier" when register module');
+  customElements.get(e.getIdentifier()) ? console.log(`Module ${r} has already registered`) : customElements.define(r, e), console.log("-------");
+}
+const h = (r) => typeof r == "object" && r !== null && !Array.isArray(r);
+function d(r) {
+  if (Array.isArray(r))
+    return r.map(d);
+  if (h(r)) {
+    const e = s({}, r);
+    if (delete e.ios, delete e.android, delete e.web, "web" in r)
+      if (h(r.web)) {
+        const t = d(e);
+        return s(s({}, t), r.web);
+      } else
+        return r.web;
+    const i = {};
+    for (const [t, n] of Object.entries(e))
+      i[t] = d(n);
+    return i;
+  }
+  return r;
+}
+function N(r) {
+  return Object.fromEntries(Object.entries(r).filter(([, e]) => e !== void 0));
+}
+export {
+  o as BaseError,
+  b as BaseModule,
+  N as cleanObjectFromUndefined,
+  d as parseClientJSON,
+  w as registerModule
+};

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@regulaforensics/idv-interfaces",
+  "version": "0.1.248-nightly",
+  "description": "Regula framework agnostic web components to work with document idv",
+  "types": "./dist/index.d.ts",
+  "main": "./dist/main.js",
+  "module": "./dist/main.js",
+  "type": "module",
+  "exports": {
+    "import": "./dist/main.js",
+    "types": "./dist/index.d.ts"
+  },
+  "files": [
+    "dist/main.js",
+    "dist/index.d.ts"
+  ],
+  "author": "Regula Forensics, Inc.",
+  "license": "MIT",
+  "homepage": "https://storybook-face.regulaforensics.com/",
+  "scripts": {
+    "build": "vite build",
+    "test": "vitest run"
+  }
+}