@yuuvis/client-framework 0.6.5

package/esm2022/object-form/lib/object-form-script/object-form-script.service.mjs

@@ -0,0 +1,115 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { BackendService, Logger } from '@yuuvis/client-core';
+import { forkJoin as observableForkJoin } from 'rxjs';
+import { map as _map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@yuuvis/client-core";
+/**
+ * @ignore
+ */
+export class ObjectFormScriptService {
+    constructor(logger, backend) {
+        this.logger = logger;
+        this.backend = backend;
+    }
+    /**
+     * Run a form script.
+     * @param scope - the current scripting scope
+     * @param script - the script to be executed
+     * @param [scriptName] - the scripts name
+     */
+    runFormScript(scope, script, scriptName) {
+        try {
+            // Define form script the function
+            const formScriptFunction = this.defineFunction('Formscript/' + scriptName, script);
+            // run the form script
+            const formScriptReturn = formScriptFunction(scope);
+            // Check if the form script returns something and may export global scripts
+            if (formScriptReturn) {
+                this.importGlobalScriptsAndCallInit(scope, formScriptReturn);
+            }
+        }
+        catch (e) {
+            if (e instanceof SyntaxError) {
+                alert('Syntax error in Form-Script. See console log for details.');
+            }
+            this.logger.error('Got script error', e);
+        }
+    }
+    /**
+     * Define form script function, appending source url as comment.
+     * Enables debugging using browser debugging tools (Chrome+Firefox)
+     * @see: https://developer.mozilla.org/en-US/docs/Tools/Debugger/How_to/Debug_eval_sources
+     *
+     * @param name - the name of the script
+     * @param script - script to be wrapped in a function
+     * @returns the function
+     */
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    defineFunction(name, script) {
+        // Appending source url as comment. See https://developer.mozilla.org/en-US/docs/Tools/Debugger/How_to/Debug_eval_sources
+        // Enables debugging using browser debugging tools (Chrome+Firefox)
+        // The line feed is needed, if the script has a comment in the last line
+        return new Function('scope', script + '\n;//# sourceURL=' + name + '.js');
+    }
+    /**
+     * If the script contains global script, this function will import and run them
+     * before running the actual script.
+     *
+     * @param scope - the current scripting scope
+     * @param formScriptReturn - the return value of the actual form script
+     */
+    importGlobalScriptsAndCallInit(scope, formScriptReturn) {
+        if (!formScriptReturn.init) {
+            return;
+        }
+        if (formScriptReturn.uses) {
+            // collect the global script exports promises
+            const exports = [];
+            const globals = [];
+            // collect Observables for fetching global scripts
+            for (const use of formScriptReturn.uses) {
+                globals.push(this.resolveGlobalScript(use, scope));
+            }
+            observableForkJoin(globals).subscribe((globalReturns) => {
+                for (const scriptReturn of globalReturns) {
+                    exports.push(scriptReturn['exports']);
+                }
+                // Invoke init function on form script return with the
+                // collected exports using javascript apply magic
+                formScriptReturn.init.apply(this, exports);
+            });
+        }
+        else {
+            // invoke init direct (no use of global scripts)
+            formScriptReturn.init();
+        }
+    }
+    /**
+     * Fetch global scripts.
+     * @param name - the name of the global script
+     * @param scope - the current scripting scope
+     * @returns
+     */
+    resolveGlobalScript(name, scope) {
+        const requestOptions = {
+            headers: new HttpHeaders({
+                Accept: 'text/plain'
+            }),
+            responseType: 'text'
+        };
+        return this.backend.get(`/script/${name}/script`, undefined, requestOptions).pipe(_map((res) => {
+            // define the global function ...
+            const globalScript = this.defineFunction('Global/' + name, res);
+            // ... and run it
+            return globalScript(scope);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectFormScriptService, deps: [{ token: i1.Logger }, { token: i1.BackendService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectFormScriptService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectFormScriptService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.Logger }, { type: i1.BackendService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-form-script.service.js","sourceRoot":"","sources":["../../../../../../../../libs/yuuvis/client-framework/object-form/src/lib/object-form-script/object-form-script.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpHeaders } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { BackendService, Logger } from '@yuuvis/client-core';\nimport { Observable, forkJoin as observableForkJoin } from 'rxjs';\nimport { map as _map } from 'rxjs/operators';\nimport { ObjectFormScriptingScope } from './object-form-scripting-scope';\n\n\n/**\n * @ignore\n */\n@Injectable()\nexport class ObjectFormScriptService {\n  constructor(private logger: Logger, private backend: BackendService) { }\n\n  /**\n   * Run a form script.\n   * @param scope - the current scripting scope\n   * @param script - the script to be executed\n   * @param [scriptName] - the scripts name\n   */\n  public runFormScript(scope: ObjectFormScriptingScope, script: any, scriptName?: string) {\n    try {\n      // Define form script the function\n      const formScriptFunction = this.defineFunction('Formscript/' + scriptName, script);\n      // run the form script\n      const formScriptReturn = formScriptFunction(scope);\n      // Check if the form script returns something and may export global scripts\n      if (formScriptReturn) {\n        this.importGlobalScriptsAndCallInit(scope, formScriptReturn);\n      }\n    } catch (e) {\n      if (e instanceof SyntaxError) {\n        alert('Syntax error in Form-Script. See console log for details.');\n      }\n      this.logger.error('Got script error', e);\n    }\n  }\n\n  /**\n   * Define form script function, appending source url as comment.\n   * Enables debugging using browser debugging tools (Chrome+Firefox)\n   * @see: https://developer.mozilla.org/en-US/docs/Tools/Debugger/How_to/Debug_eval_sources\n   *\n   * @param name - the name of the script\n   * @param script - script to be wrapped in a function\n   * @returns the function\n   */\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  private defineFunction(name: string, script: any): Function {\n    // Appending source url as comment. See https://developer.mozilla.org/en-US/docs/Tools/Debugger/How_to/Debug_eval_sources\n    // Enables debugging using browser debugging tools (Chrome+Firefox)\n    // The line feed is needed, if the script has a comment in the last line\n    return new Function('scope', script + '\\n;//# sourceURL=' + name + '.js');\n  }\n\n  /**\n   * If the script contains global script, this function will import and run them\n   * before running the actual script.\n   *\n   * @param scope - the current scripting scope\n   * @param formScriptReturn - the return value of the actual form script\n   */\n  private importGlobalScriptsAndCallInit(scope: ObjectFormScriptingScope, formScriptReturn: any) {\n    if (!formScriptReturn.init) {\n      return;\n    }\n\n    if (formScriptReturn.uses) {\n      // collect the global script exports promises\n      const exports: any[] = [];\n      const globals = [];\n\n      // collect Observables for fetching global scripts\n      for (const use of formScriptReturn.uses) {\n        globals.push(this.resolveGlobalScript(use, scope));\n      }\n\n      observableForkJoin(globals).subscribe((globalReturns) => {\n        for (const scriptReturn of globalReturns) {\n          exports.push(scriptReturn['exports']);\n        }\n        // Invoke init function on form script return with the\n        // collected exports using javascript apply magic\n        formScriptReturn.init.apply(this, exports);\n      });\n    } else {\n      // invoke init direct (no use of global scripts)\n      formScriptReturn.init();\n    }\n  }\n\n  /**\n   * Fetch global scripts.\n   * @param name - the name of the global script\n   * @param scope - the current scripting scope\n   * @returns\n   */\n  private resolveGlobalScript(name: string, scope: ObjectFormScriptingScope): Observable<any> {\n    const requestOptions = {\n      headers: new HttpHeaders({\n        Accept: 'text/plain'\n      }),\n      responseType: 'text'\n    };\n\n    return this.backend.get(`/script/${name}/script`, undefined, requestOptions).pipe(\n      _map((res: any) => {\n        // define the global function ...\n        const globalScript = this.defineFunction('Global/' + name, res);\n        // ... and run it\n        return globalScript(scope);\n      })\n    );\n  }\n}\n"]}

package/esm2022/object-form/lib/object-form-script/object-form-scripting-scope.mjs

@@ -0,0 +1,251 @@
+/**
+ * @ignore
+ * This class will be injected as scope into form scripts.
+ */
+export class ObjectFormScriptingScope {
+    /**
+     * Constructor
+     * @param situation - Current form model situation (could be CREATE, SEARCH or EDIT)
+     * @param onScriptingModelChange - callback function to be called when the scripting model changed
+     * Be aware to provide an instance method as callback for the scripting scope.
+     * @see: https://blog.johnnyreilly.com/2014/04/typescript-instance-methods.html
+     *
+     * @param api - Plugin API reference
+     * @param isTableRowScope - set this to true if the current scripting scope is created for a
+     * row editing form from a table element. It will then provide the right parameters for the scripting functions
+     */
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    constructor(situation, onScriptingModelChange, api, isTableRowScope) {
+        this.situation = situation;
+        this.onScriptingModelChange = onScriptingModelChange;
+        this.api = api;
+        this.isTableRowScope = isTableRowScope;
+        // List of all form fields (elements)
+        this.model = {};
+        // all data values including invisible elements (READONLY)
+        this.data = {};
+        // actions passed by BPM forms
+        this.actions = {};
+        // additional objects provided by the object form
+        // used for example to pass dms objects attached to a work item
+        // to the script (READONLY)
+        // may contain: FormScriptDmsObject, FileEntry
+        this.objects = [];
+        this.context = { id: '', title: '', objectTypeId: '' };
+    }
+    /**
+     * Sets the internal model and wraps every model element with an observer to be
+     * able to track their changes from within a form script
+     * @param model
+     */
+    setModel(model) {
+        this.model = {};
+        for (const k of Object.keys(model)) {
+            this.model[k] = new ScopeElement(model[k], this.onScriptingModelChange);
+        }
+    }
+    /**
+     * Returns the observed model. Used for row editing forms of table elements that
+     * create their own scripting scope in context of their parent form.
+     * @returns the observed scripting scope model
+     */
+    getModel() {
+        return this.model;
+    }
+    /**
+     * Called by the object form when the form model changes.
+     * @param change - object with key equals name of the element
+     * that changes and value of the new value
+     */
+    modelChanged(change) {
+        // find the changed element in the scopes model
+        const propertyName = Object.keys(change)[0];
+        if (change[propertyName] === undefined) {
+            return;
+        }
+        if (this.model[propertyName]) {
+            const el = this.model[propertyName];
+            el.update(change[propertyName], this.model);
+        }
+    }
+}
+/**
+ * @ignore
+ */
+class ScopeElement {
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    constructor(element, onScriptingModelChange) {
+        this.element = element;
+        this.onScriptingModelChange = onScriptingModelChange;
+        if (this.element.value === undefined) {
+            this.element.value = null;
+        }
+        if (this.isProxyable(this.element.value)) {
+            this.element.value = this.createProxy(this.element.value);
+        }
+    }
+    isProxyable(value, key) {
+        return ((typeof value === 'object' || Array.isArray(value)) &&
+            value !== null &&
+            !(value instanceof Date) &&
+            !value.isProxy &&
+            (key ? !key.includes('_meta') : true));
+    }
+    createProxy(value) {
+        const handler = {
+            set: (target, key, val) => {
+                const previousValue = structuredClone(this.element.value);
+                if (this.isProxyable(val, key)) {
+                    target[key] = this.createProxy(val);
+                }
+                else {
+                    target[key] = val;
+                }
+                if (this.hasValueChanged(this.element.value, previousValue) && !key.includes('_meta')) {
+                    this.onScriptingModelChange(this.element.name, { newValue: structuredClone(this.element.value), name: 'value' });
+                }
+                return true;
+            },
+            // This get trap is only used to find out, if an object is a proxy or not.
+            get: (target, key) => {
+                if (key === 'isProxy') {
+                    return true;
+                }
+                return target[key];
+            }
+        };
+        Object.keys(value).forEach((key) => {
+            if (this.isProxyable(value[key], key)) {
+                value[key] = this.createProxy(value[key]);
+            }
+        });
+        return new Proxy(value, handler);
+    }
+    hasValueChanged(value1, value2) {
+        return JSON.stringify(value1) !== JSON.stringify(value2);
+    }
+    update(value, model) {
+        const newValue = structuredClone(value);
+        if (this.hasValueChanged(this.element.value, value)) {
+            if (this.isProxyable(value)) {
+                this.element.value = this.createProxy(newValue);
+            }
+            else {
+                this.element.value = newValue;
+            }
+            if (this.element.onchange) {
+                this.element.onchange(this, model);
+            }
+        }
+    }
+    set value(value) {
+        if (this.hasValueChanged(this.element.value, value)) {
+            if (this.isProxyable(value)) {
+                this.element.value = this.createProxy(value);
+            }
+            else {
+                this.element.value = value;
+            }
+            this.onScriptingModelChange(this.element.name, { newValue: structuredClone(this.element.value), name: 'value' });
+        }
+    }
+    get value() {
+        return this.element.value;
+    }
+    set onchange(onchange) {
+        this.element.onchange = onchange;
+        this.onScriptingModelChange(this.element.name, { newValue: onchange, name: 'onchange' });
+    }
+    get onchange() {
+        return this.element.onchange;
+    }
+    set required(required) {
+        this.element.required = required;
+        this.onScriptingModelChange(this.element.name, { newValue: required, name: 'required' });
+    }
+    get required() {
+        return this.element.required;
+    }
+    set readonly(readonly) {
+        this.element.readonly = readonly;
+        this.onScriptingModelChange(this.element.name, { newValue: readonly, name: 'readonly' });
+    }
+    get readonly() {
+        return this.element.readonly;
+    }
+    set error(error) {
+        this.element.error = error;
+        this.onScriptingModelChange(this.element.name, { newValue: error, name: 'error' });
+    }
+    get error() {
+        return this.element.error;
+    }
+    set onrowedit(onrowedit) {
+        this.element.onrowedit = onrowedit;
+        this.onScriptingModelChange(this.element.name, { newValue: onrowedit, name: 'onrowedit' });
+    }
+    get onrowedit() {
+        return this.element.onrowedit;
+    }
+    setList(obj) {
+        if (this.element.setList) {
+            this.element.setList(obj);
+        }
+    }
+    applyFilter(obj) {
+        if (this.element.applyFilter) {
+            this.element.applyFilter(obj);
+        }
+    }
+    setFilter(obj) {
+        if (this.element.setFilter) {
+            this.element.setFilter(obj);
+        }
+    }
+    get name() {
+        return this.element.name;
+    }
+    get qname() {
+        return this.element.qname;
+    }
+    get label() {
+        return this.element.label;
+    }
+    get description() {
+        return this.element.description;
+    }
+    get type() {
+        return this.element.type;
+    }
+    get multiselect() {
+        return this.element.multiselect;
+    }
+    get codesystem() {
+        return this.element.codesystem;
+    }
+    get minlen() {
+        return this.element.minLength;
+    }
+    get maxlen() {
+        return this.element.maxLength;
+    }
+    get classifications() {
+        return this.element.classifications;
+    }
+    get scale() {
+        return this.element.scale;
+    }
+    get precision() {
+        return this.element.precision;
+    }
+    get withtime() {
+        return this.element.withtime;
+    }
+    get elements() {
+        return this.element.elements;
+    }
+    get aliases() {
+        return this.element.aliases;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object-form-scripting-scope.js","sourceRoot":"","sources":["../../../../../../../../libs/yuuvis/client-framework/object-form/src/lib/object-form-script/object-form-scripting-scope.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @ignore\n * This class will be injected as scope into form scripts.\n */\nexport class ObjectFormScriptingScope {\n  // List of all form fields (elements)\n  public model: any = {};\n\n  // all data values including invisible elements (READONLY)\n  public data: any = {};\n\n  // The id of the current DMS-Object (READONLY)\n  public objectId?: string;\n\n  // actions passed by BPM forms\n  public actions: any = {};\n  // additional objects provided by the object form\n  // used for example to pass dms objects attached to a work item\n  // to the script (READONLY)\n  // may contain: FormScriptDmsObject, FileEntry\n  public objects: any[] = [];\n  public context: { id: string; title: string; objectTypeId: string } = { id: '', title: '', objectTypeId: '' };\n\n  /**\n   * Constructor\n   * @param situation - Current form model situation (could be CREATE, SEARCH or EDIT)\n   * @param onScriptingModelChange - callback function to be called when the scripting model changed\n   * Be aware to provide an instance method as callback for the scripting scope.\n   * @see: https://blog.johnnyreilly.com/2014/04/typescript-instance-methods.html\n   *\n   * @param api - Plugin API reference\n   * @param isTableRowScope - set this to true if the current scripting scope is created for a\n   * row editing form from a table element. It will then provide the right parameters for the scripting functions\n   */\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  constructor(public situation: string, private onScriptingModelChange: Function, public api: any, private isTableRowScope?: boolean) {}\n\n  /**\n   * Sets the internal model and wraps every model element with an observer to be\n   * able to track their changes from within a form script\n   * @param model\n   */\n  public setModel(model: any) {\n    this.model = {};\n    for (const k of Object.keys(model)) {\n      this.model[k] = new ScopeElement(model[k], this.onScriptingModelChange);\n    }\n  }\n\n  /**\n   * Returns the observed model. Used for row editing forms of table elements that\n   * create their own scripting scope in context of their parent form.\n   * @returns the observed scripting scope model\n   */\n  public getModel() {\n    return this.model;\n  }\n\n  /**\n   * Called by the object form when the form model changes.\n   * @param change - object with key equals name of the element\n   * that changes and value of the new value\n   */\n  public modelChanged(change: any) {\n    // find the changed element in the scopes model\n    const propertyName = Object.keys(change)[0];\n    if (change[propertyName] === undefined) {\n      return;\n    }\n\n    if (this.model[propertyName]) {\n      const el = this.model[propertyName];\n      el.update(change[propertyName], this.model);\n    }\n  }\n}\n/**\n * @ignore\n */\nclass ScopeElement {\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  constructor(private element: any, private onScriptingModelChange: Function) {\n    if (this.element.value === undefined) {\n      this.element.value = null;\n    }\n    if (this.isProxyable(this.element.value)) {\n      this.element.value = this.createProxy(this.element.value);\n    }\n  }\n\n  private isProxyable(value: any, key?: string) {\n    return (\n      (typeof value === 'object' || Array.isArray(value)) &&\n      value !== null &&\n      !(value instanceof Date) &&\n      !value.isProxy &&\n      (key ? !key.includes('_meta') : true)\n    );\n  }\n\n  private createProxy(value: any) {\n    const handler = {\n      set: (target: Record<string, unknown>, key: string, val: unknown) => {\n        const previousValue = structuredClone(this.element.value);\n        if (this.isProxyable(val, key)) {\n          target[key] = this.createProxy(val);\n        } else {\n          target[key] = val;\n        }\n        if (this.hasValueChanged(this.element.value, previousValue) && !key.includes('_meta')) {\n          this.onScriptingModelChange(this.element.name, { newValue: structuredClone(this.element.value), name: 'value' });\n        }\n        return true;\n      },\n      // This get trap is only used to find out, if an object is a proxy or not.\n      get: (target: Record<string, unknown>, key: string) => {\n        if (key === 'isProxy') {\n          return true;\n        }\n        return target[key];\n      }\n    };\n\n    Object.keys(value).forEach((key) => {\n      if (this.isProxyable(value[key], key)) {\n        value[key] = this.createProxy(value[key]);\n      }\n    });\n    return new Proxy(value, handler);\n  }\n\n  private hasValueChanged(value1: unknown, value2: unknown) {\n    return JSON.stringify(value1) !== JSON.stringify(value2);\n  }\n\n  update(value: unknown, model: any) {\n    const newValue = structuredClone(value);\n    if (this.hasValueChanged(this.element.value, value)) {\n      if (this.isProxyable(value)) {\n        this.element.value = this.createProxy(newValue);\n      } else {\n        this.element.value = newValue;\n      }\n      if (this.element.onchange) {\n        this.element.onchange(this, model);\n      }\n    }\n  }\n\n  set value(value) {\n    if (this.hasValueChanged(this.element.value, value)) {\n      if (this.isProxyable(value)) {\n        this.element.value = this.createProxy(value);\n      } else {\n        this.element.value = value;\n      }\n      this.onScriptingModelChange(this.element.name, { newValue: structuredClone(this.element.value), name: 'value' });\n    }\n  }\n\n  get value() {\n    return this.element.value;\n  }\n\n  set onchange(onchange) {\n    this.element.onchange = onchange;\n    this.onScriptingModelChange(this.element.name, { newValue: onchange, name: 'onchange' });\n  }\n\n  get onchange() {\n    return this.element.onchange;\n  }\n\n  set required(required) {\n    this.element.required = required;\n    this.onScriptingModelChange(this.element.name, { newValue: required, name: 'required' });\n  }\n\n  get required() {\n    return this.element.required;\n  }\n\n  set readonly(readonly) {\n    this.element.readonly = readonly;\n    this.onScriptingModelChange(this.element.name, { newValue: readonly, name: 'readonly' });\n  }\n\n  get readonly() {\n    return this.element.readonly;\n  }\n\n  set error(error) {\n    this.element.error = error;\n    this.onScriptingModelChange(this.element.name, { newValue: error, name: 'error' });\n  }\n\n  get error() {\n    return this.element.error;\n  }\n\n  set onrowedit(onrowedit) {\n    this.element.onrowedit = onrowedit;\n    this.onScriptingModelChange(this.element.name, { newValue: onrowedit, name: 'onrowedit' });\n  }\n\n  get onrowedit() {\n    return this.element.onrowedit;\n  }\n\n  setList(obj: any) {\n    if (this.element.setList) {\n      this.element.setList(obj);\n    }\n  }\n\n  applyFilter(obj: any) {\n    if (this.element.applyFilter) {\n      this.element.applyFilter(obj);\n    }\n  }\n\n  setFilter(obj: any) {\n    if (this.element.setFilter) {\n      this.element.setFilter(obj);\n    }\n  }\n\n  get name() {\n    return this.element.name;\n  }\n\n  get qname() {\n    return this.element.qname;\n  }\n\n  get label() {\n    return this.element.label;\n  }\n\n  get description() {\n    return this.element.description;\n  }\n\n  get type() {\n    return this.element.type;\n  }\n\n  get multiselect() {\n    return this.element.multiselect;\n  }\n\n  get codesystem() {\n    return this.element.codesystem;\n  }\n\n  get minlen() {\n    return this.element.minLength;\n  }\n\n  get maxlen() {\n    return this.element.maxLength;\n  }\n\n  get classifications() {\n    return this.element.classifications;\n  }\n\n  get scale() {\n    return this.element.scale;\n  }\n\n  get precision() {\n    return this.element.precision;\n  }\n\n  get withtime() {\n    return this.element.withtime;\n  }\n\n  get elements() {\n    return this.element.elements;\n  }\n\n  get aliases() {\n    return this.element.aliases;\n  }\n}\n"]}

package/esm2022/object-form/lib/object-form-translate.service.mjs

@@ -0,0 +1,73 @@
+import { inject, Injectable } from '@angular/core';
+import { TranslateService } from '@yuuvis/client-core';
+import * as i0 from "@angular/core";
+/**
+ * Providing an error message when a translation string for an object wasn't found
+ */
+export class ObjectFormTranslateService {
+    constructor() {
+        this.translate = inject(TranslateService);
+    }
+    /**
+     * Set the error label if a translation for this string wasn't provided
+     * @param error - error message about a missed translation key
+     * @param params
+     */
+    getErrorLabel(error, params) {
+        switch (error) {
+            case 'daterange':
+                return this.translate.instant('yuv.object-form-element.error.daterange.invalid', params);
+            case 'daterangeorder':
+                return this.translate.instant('yuv.object-form-element.error.daterangeorder.invalid', params);
+            case 'numberrange':
+                return this.translate.instant('yuv.object-form-element.error.numberrange.invalid', params);
+            case 'numberrangeorder':
+                return this.translate.instant('yuv.object-form-element.error.numberrangeorder.invalid', params);
+            case 'number':
+                return this.translate.instant('yuv.object-form-element.error.number', params);
+            case 'precision':
+                return this.translate.instant('yuv.object-form-element.error.number.precision', params);
+            case 'scale':
+                return this.translate.instant('yuv.object-form-element.error.number.scale', params);
+            case 'regex':
+                return this.translate.instant('yuv.object-form-element.error.string.regex.nomatch', params);
+            case 'pattern':
+                return this.translate.instant('yuv.object-form-element.error.string.regex.nomatch', params);
+            case 'classificationemail':
+                return this.translate.instant('yuv.object-form-element.error.string.classification.email', params);
+            case 'classificationphone':
+                return this.translate.instant('yuv.object-form-element.error.string.classification.phone', params);
+            case 'classificationurl':
+                return this.translate.instant('yuv.object-form-element.error.string.classification.url', params);
+            case 'onlyWhitespaces':
+                return this.translate.instant('yuv.object-form-element.error.string.whitespaces', params);
+            case 'datecontrol':
+                return this.translate.instant('yuv.object-form-element.error.date.invalid', params);
+            case 'required':
+                return this.translate.instant('yuv.object-form-element.error.required', params);
+            case 'maxlength':
+                return this.translate.instant('yuv.object-form-element.error.maxlength', params);
+            case 'minlength':
+                return this.translate.instant('yuv.object-form-element.error.minlength', params);
+            case 'minmax':
+                return this.translate.instant('yuv.object-form-element.error.minmax', params);
+            case 'minvalue':
+                return this.translate.instant('yuv.object-form-element.error.minvalue', params);
+            case 'maxvalue':
+                return this.translate.instant('yuv.object-form-element.error.maxvalue', params);
+            case 'empty':
+                return this.translate.instant('yuv.object-form-element.recent-activities.list.empty', params);
+            default:
+                return this.translate.instant(error, params);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectFormTranslateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectFormTranslateService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ObjectFormTranslateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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