@yuuvis/client-core 0.6.5

package/esm2022/lib/service/pending-changes/pending-changes.service.mjs

@@ -0,0 +1,123 @@
+import { inject, Injectable } from '@angular/core';
+import { ReplaySubject } from 'rxjs';
+import { Utils } from '../../util/utils';
+import { Logger } from '../logger/logger';
+import * as i0 from "@angular/core";
+/**
+ * EditingObserver service is used to track changes made inside the application, that should prevent
+ * doing something or going somewhere before the changes are persisted or ignored. For example when
+ * the user starts editing form data and tries to navigate away before saving the changes, this service
+ * will take care of notifying the user.
+ *
+ * It is working kind of like a registry for ongoing tasks that need to be monitored. Every component
+ * that needs to be aware of changes to be persisted can start a task and finish it when everything is done.
+ *
+ * Other components can ask the service for pending tasks to know whether or not to execute an action
+ * (e.g. list component will subscribe and prevent selecting another list item, if changes to the previous one haven't be finished)
+ *
+ * app.component will prevent relevant route changes while tasks are pending.
+ */
+export class PendingChangesService {
+    constructor() {
+        this.#logger = inject(Logger);
+        this.#tasks = [];
+        this.#tasksSource = new ReplaySubject();
+        this.tasks$ = this.#tasksSource.asObservable();
+        // private customMsg = '';
+        this.#defaultMsg = 'You are currently editing the index data of a form that has not been saved. Unsaved data will be lost.';
+    }
+    #logger;
+    #tasks;
+    #tasksSource;
+    // private customMsg = '';
+    #defaultMsg;
+    /**
+     * Registers a task to be pending.
+     * @param message alert message
+     * @returns Unique id to be used for finishing this task
+     */
+    startTask(message) {
+        const taskId = Utils.uuid();
+        this.#tasks.push({ id: taskId, message: message });
+        this.#logger.debug('started pending task: ' + taskId);
+        this.#tasksSource.next(this.#tasks);
+        return taskId;
+    }
+    /**
+     * Finishes a task
+     * @param id The id of the task to be finished. This is the one the component got from startTask()
+     */
+    finishTask(id) {
+        if (id) {
+            this.#tasks = this.#tasks.filter((t) => t.id !== id);
+            this.#tasksSource.next(this.#tasks);
+            this.#logger.debug('finished pending task: ' + id);
+        }
+    }
+    /**
+     * Returns whether or not the service has pending tasks.
+     * If an id is provided, the method will check existence of one specific task.
+     *
+     * @param id The id of the task to be checked
+     * @returns
+     */
+    hasPendingTask(id) {
+        return !id ? !!this.#tasks.length : Array.isArray(id) ? this.#tasks.some((value) => id.includes(value.id)) : this.#tasks.map((t) => t.id).includes(id);
+    }
+    /**
+     * Returns whether or not the component|service has pending tasks.
+     * Checks via confirm dialog
+     * @param component
+     * @returns
+     */
+    check(component) {
+        if (component && component.hasPendingChanges ? !component.hasPendingChanges() : !this.hasPendingTask()) {
+            return false;
+        }
+        else {
+            const confirmed = confirm(this.#getConfirmMessage());
+            if (confirmed) {
+                this.clear();
+            }
+            return !confirmed;
+        }
+    }
+    checkForPendingTasks(taskIds) {
+        if (this.hasPendingTask(taskIds)) {
+            const confirmed = confirm(this.#getConfirmMessage());
+            if (confirmed) {
+                this.clear();
+            }
+            return !confirmed;
+        }
+        else {
+            return false;
+        }
+    }
+    #getConfirmMessage() {
+        let msg = '';
+        this.#tasks.forEach((t) => {
+            // do not apply messages twice
+            if (msg.indexOf(t.message || this.#defaultMsg) === -1) {
+                msg = `${msg}${msg.length > 0 ? '\n---\n' : ''}${t.message || this.#defaultMsg}`;
+            }
+        });
+        return msg;
+    }
+    /**
+     * Clear list of pending tasks
+     */
+    clear() {
+        this.#tasks = [];
+        this.#tasksSource.next(this.#tasks);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PendingChangesService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PendingChangesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PendingChangesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pending-changes.service.js","sourceRoot":"","sources":["../../../../../../../../libs/yuuvis/client-core/src/lib/service/pending-changes/pending-changes.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { Observable, ReplaySubject } from 'rxjs';\nimport { Utils } from '../../util/utils';\nimport { Logger } from '../logger/logger';\nimport { PendingChangesComponent } from './pending-changes-component.interface';\n\n/**\n * EditingObserver service is used to track changes made inside the application, that should prevent\n * doing something or going somewhere before the changes are persisted or ignored. For example when\n * the user starts editing form data and tries to navigate away before saving the changes, this service\n * will take care of notifying the user.\n *\n * It is working kind of like a registry for ongoing tasks that need to be monitored. Every component\n * that needs to be aware of changes to be persisted can start a task and finish it when everything is done.\n *\n * Other components can ask the service for pending tasks to know whether or not to execute an action\n * (e.g. list component will subscribe and prevent selecting another list item, if changes to the previous one haven't be finished)\n *\n * app.component will prevent relevant route changes while tasks are pending.\n */\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class PendingChangesService {\n  #logger = inject(Logger);\n\n  #tasks: { id: string; message?: string }[] = [];\n  #tasksSource = new ReplaySubject<{ id: string; message?: string }[]>();\n  tasks$: Observable<{ id: string; message?: string }[]> = this.#tasksSource.asObservable();\n\n  // private customMsg = '';\n  #defaultMsg = 'You are currently editing the index data of a form that has not been saved. Unsaved data will be lost.';\n\n  /**\n   * Registers a task to be pending.\n   * @param message alert message\n   * @returns Unique id to be used for finishing this task\n   */\n  startTask(message: string): string {\n    const taskId = Utils.uuid();\n    this.#tasks.push({ id: taskId, message: message });\n    this.#logger.debug('started pending task: ' + taskId);\n    this.#tasksSource.next(this.#tasks);\n    return taskId;\n  }\n\n  /**\n   * Finishes a task\n   * @param id The id of the task to be finished. This is the one the component got from startTask()\n   */\n  finishTask(id: string) {\n    if (id) {\n      this.#tasks = this.#tasks.filter((t) => t.id !== id);\n      this.#tasksSource.next(this.#tasks);\n      this.#logger.debug('finished pending task: ' + id);\n    }\n  }\n\n  /**\n   * Returns whether or not the service has pending tasks.\n   * If an id is provided, the method will check existence of one specific task.\n   *\n   * @param id The id of the task to be checked\n   * @returns\n   */\n  hasPendingTask(id?: string | string[]): boolean {\n    return !id ? !!this.#tasks.length : Array.isArray(id) ? this.#tasks.some((value) => id.includes(value.id)) : this.#tasks.map((t) => t.id).includes(id);\n  }\n\n  /**\n   * Returns whether or not the component|service has pending tasks.\n   * Checks via confirm dialog\n   * @param component\n   * @returns\n   */\n  check(component?: PendingChangesComponent): boolean {\n    if (component && component.hasPendingChanges ? !component.hasPendingChanges() : !this.hasPendingTask()) {\n      return false;\n    } else {\n      const confirmed = confirm(this.#getConfirmMessage());\n      if (confirmed) {\n        this.clear();\n      }\n      return !confirmed;\n    }\n  }\n\n  checkForPendingTasks(taskIds: string | string[]): boolean {\n    if (this.hasPendingTask(taskIds)) {\n      const confirmed = confirm(this.#getConfirmMessage());\n      if (confirmed) {\n        this.clear();\n      }\n      return !confirmed;\n    } else {\n      return false;\n    }\n  }\n\n  #getConfirmMessage(): string {\n    let msg = '';\n    this.#tasks.forEach((t) => {\n      // do not apply messages twice\n      if (msg.indexOf(t.message || this.#defaultMsg) === -1) {\n        msg = `${msg}${msg.length > 0 ? '\\n---\\n' : ''}${t.message || this.#defaultMsg}`;\n      }\n    });\n    return msg;\n  }\n\n  /**\n   * Clear list of pending tasks\n   */\n  clear() {\n    this.#tasks = [];\n    this.#tasksSource.next(this.#tasks);\n  }\n}\n"]}

package/esm2022/lib/service/prediction/prediction.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJlZGljdGlvbi5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL3l1dXZpcy9jbGllbnQtY29yZS9zcmMvbGliL3NlcnZpY2UvcHJlZGljdGlvbi9wcmVkaWN0aW9uLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBQcmVkaWN0aW9uQ2xhc3NpZnlSZXN1bHQge1xuICBvYmplY3RJZDogc3RyaW5nO1xuICBwcm9wZXJ0aWVzOiBQcmVkaWN0aW9uQ2xhc3NpZnlSZXN1bHRJdGVtW107XG59XG5leHBvcnQgaW50ZXJmYWNlIFByZWRpY3Rpb25DbGFzc2lmeVJlc3VsdEl0ZW0ge1xuICB0eXBlOiBzdHJpbmc7XG4gIHByb2JhYmlsaXR5OiBudW1iZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUHJlZGljdGlvbkV4dHJhY3RSZXN1bHQge1xuICBvYmplY3RJZDogc3RyaW5nO1xuICAvLyBSZWNvcmQgd2hlcmUgdGhlIGtleSBpcyB0aGUgcHJvcGVydHkgbmFtZSBhbmQgdGhlIHZhbHVlIGlzIGFuXG4gIC8vIGFycmF5IG9mIHByZWRpY3Rpb25zIGZvciB0aGF0IHByb3BlcnR5XG4gIHByb3BlcnRpZXM6IFJlY29yZDxzdHJpbmcsIFByZWRpY3Rpb25FeHRyYWN0UmVzdWx0SXRlbVtdPjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBQcmVkaWN0aW9uRXh0cmFjdFJlc3VsdEl0ZW0ge1xuICB2YWx1ZTogc3RyaW5nO1xuICBwcm9iYWJpbGl0eTogbnVtYmVyO1xuICBib3VuZGluZ0JveD86IG51bWJlcltdO1xuICBwYWdlPzogbnVtYmVyO1xufVxuIl19

package/esm2022/lib/service/prediction/prediction.service.mjs

@@ -0,0 +1,60 @@
+import { Injectable, inject } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { BackendService } from '../backend/backend.service';
+import { BaseObjectTypeField } from '../system/system.enum';
+import { ApiBase } from './../backend/api.enum';
+import * as i0 from "@angular/core";
+export class PredictionService {
+    #backend = inject(BackendService);
+    classify(objectIDs, schemaObjectTypeId = 'CLASSIFICATION') {
+        const objects = objectIDs.map((objectID) => ({
+            properties: {
+                [BaseObjectTypeField.OBJECT_ID]: {
+                    value: objectID
+                }
+            }
+        }));
+        return this.#backend.post(`/classification?schemaObjectTypeId=${schemaObjectTypeId}`, { objects }, ApiBase.predict).pipe(map((res) => res.predictions.reduce((acc, curr) => ({
+            ...acc,
+            [curr[BaseObjectTypeField.OBJECT_ID].value]: {
+                objectId: curr[BaseObjectTypeField.OBJECT_ID].value,
+                properties: Object.keys(curr.properties).map((type) => ({
+                    type,
+                    probability: curr.properties[type].probability
+                }))
+            }
+        }), {})));
+    }
+    /**
+     * @param schemaObjectTypeId
+     * @param objectIDs
+     * @returns  Observable<Record<string, PredictionClassifyResult>> string is objectID
+     */
+    extract(schemaObjectTypeId, objectIDs) {
+        const searchParams = new URLSearchParams();
+        searchParams.append('schemaObjectTypeId', schemaObjectTypeId);
+        const objects = objectIDs.map((objectID) => ({
+            properties: {
+                [BaseObjectTypeField.OBJECT_ID]: {
+                    value: objectID
+                }
+            }
+        }));
+        return this.#backend.post(`/extraction?${searchParams.toString()}`, { objects }, ApiBase.predict).pipe(map((res) => res.predictions.reduce((acc, curr) => ({
+            ...acc,
+            [curr[BaseObjectTypeField.OBJECT_ID].value]: {
+                objectId: curr[BaseObjectTypeField.OBJECT_ID].value,
+                properties: curr.properties
+            }
+        }), {})));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PredictionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PredictionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: PredictionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/service/search/search.service.interface.mjs

@@ -0,0 +1,39 @@
+export var Operator;
+(function (Operator) {
+    Operator["EQUAL"] = "eq";
+    Operator["EEQUAL"] = "eeq";
+    Operator["IN"] = "in";
+    Operator["GREATER_THAN"] = "gt";
+    Operator["GREATER_OR_EQUAL"] = "gte";
+    Operator["LESS_THAN"] = "lt";
+    Operator["LESS_OR_EQUAL"] = "lte";
+    Operator["INTERVAL"] = "gtlt";
+    Operator["INTERVAL_INCLUDE_BOTH"] = "gtelte";
+    Operator["INTERVAL_INCLUDE_TO"] = "gtlte";
+    Operator["INTERVAL_INCLUDE_FROM"] = "gtelt";
+    Operator["RANGE"] = "rg";
+    Operator["LIKE"] = "like";
+    Operator["CONTAINS"] = "contains"; // contains
+})(Operator || (Operator = {}));
+export const OperatorLabel = {
+    /** equal */
+    EQUAL: '=',
+    /** exact equal */
+    EEQUAL: '==',
+    /** match at least one of the provided values (value has to be an array)  */
+    IN: '~',
+    /** greater than */
+    GREATER_THAN: '>',
+    /** greater than or equal */
+    GREATER_OR_EQUAL: '≽', //
+    LESS_THAN: '<', // less than
+    LESS_OR_EQUAL: '≼', // less than or equal
+    INTERVAL: '<>', // interval
+    INTERVAL_INCLUDE_BOTH: '-', // interval include left and right
+    INTERVAL_INCLUDE_TO: '>-', // interval include right
+    INTERVAL_INCLUDE_FROM: '-<', // interval include left
+    RANGE: '=', // aggegation ranges
+    LIKE: '~', // like
+    CONTAINS: '~' // contains
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.service.interface.js","sourceRoot":"","sources":["../../../../../../../../libs/yuuvis/client-core/src/lib/service/search/search.service.interface.ts"],"names":[],"mappings":"AA6DA,MAAM,CAAN,IAAY,QAeX;AAfD,WAAY,QAAQ;IAClB,wBAAY,CAAA;IACZ,0BAAc,CAAA;IACd,qBAAS,CAAA;IACT,+BAAmB,CAAA;IACnB,oCAAwB,CAAA;IACxB,4BAAgB,CAAA;IAChB,iCAAqB,CAAA;IACrB,6BAAiB,CAAA;IACjB,4CAAgC,CAAA;IAChC,yCAA6B,CAAA;IAC7B,2CAA+B,CAAA;IAC/B,wBAAY,CAAA;IACZ,yBAAa,CAAA;IACb,iCAAqB,CAAA,CAAC,WAAW;AACnC,CAAC,EAfW,QAAQ,KAAR,QAAQ,QAenB;AACD,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,YAAY;IACZ,KAAK,EAAE,GAAG;IACV,kBAAkB;IAClB,MAAM,EAAE,IAAI;IACZ,4EAA4E;IAC5E,EAAE,EAAE,GAAG;IACP,mBAAmB;IACnB,YAAY,EAAE,GAAG;IACjB,4BAA4B;IAC5B,gBAAgB,EAAE,GAAG,EAAE,EAAE;IACzB,SAAS,EAAE,GAAG,EAAE,YAAY;IAC5B,aAAa,EAAE,GAAG,EAAE,qBAAqB;IACzC,QAAQ,EAAE,IAAI,EAAE,WAAW;IAC3B,qBAAqB,EAAE,GAAG,EAAE,kCAAkC;IAC9D,mBAAmB,EAAE,IAAI,EAAE,yBAAyB;IACpD,qBAAqB,EAAE,IAAI,EAAE,wBAAwB;IACrD,KAAK,EAAE,GAAG,EAAE,oBAAoB;IAChC,IAAI,EAAE,GAAG,EAAE,OAAO;IAClB,QAAQ,EAAE,GAAG,CAAC,WAAW;CAC1B,CAAC","sourcesContent":["import { ContentStream, CoreApiObject } from '../dms/dms.service.interface';\n\nexport interface SearchQuery {\n  // -- Fulltext --\n  // Search term\n  term?: string;\n  // where to search\n  scope?: 'all' | 'metadata' | 'content';\n\n  // -- Pagination --\n  // Number of items to return\n  size?: number;\n  // Number of items to skip (offset)\n  from?: number;\n\n  // -- Fields --\n  // Object fields to return\n  fields?: string[];\n\n  // -- Aggregations --\n  // Aggregations to return\n  aggs?: string[];\n\n  // -- Object Types --\n  // Object types (incl. SOTs) to search for\n  types?: string[];\n\n  // -- Filters --\n  // Filter by field\n  filters?: SearchFilter[];\n  // filters to be applied to table columns\n  tableFilters?: TableFilter[];\n\n  // -- Sort --\n  // Sort by field\n  sort?: SortOption[];\n  includePermissions?: boolean;\n}\n\nexport interface SortOption {\n  field: string;\n  order: 'asc' | 'desc';\n}\n\nexport interface SearchFilter {\n  // field to filter by\n  f: string;\n  o: Operator;\n  // value for the filter\n  v1: unknown;\n  // optional second value for interval filters\n  v2?: unknown;\n  // whether to negate the filter\n  useNot?: boolean;\n}\n\nexport interface TableFilter {\n  table: string;\n  columnFilters: SearchFilter[];\n}\n\nexport enum Operator {\n  EQUAL = 'eq', // equal\n  EEQUAL = 'eeq', // exact equal\n  IN = 'in', // match at least one of the provided values (value has to be an array)\n  GREATER_THAN = 'gt', // greater than\n  GREATER_OR_EQUAL = 'gte', // greater than or equal\n  LESS_THAN = 'lt', // less than\n  LESS_OR_EQUAL = 'lte', // less than or equal\n  INTERVAL = 'gtlt', // interval\n  INTERVAL_INCLUDE_BOTH = 'gtelte', // interval include left and right\n  INTERVAL_INCLUDE_TO = 'gtlte', // interval include right\n  INTERVAL_INCLUDE_FROM = 'gtelt', // interval include left\n  RANGE = 'rg', // aggegation ranges\n  LIKE = 'like', // like\n  CONTAINS = 'contains' // contains\n}\nexport const OperatorLabel = {\n  /** equal */\n  EQUAL: '=',\n  /** exact equal */\n  EEQUAL: '==',\n  /** match at least one of the provided values (value has to be an array)  */\n  IN: '~',\n  /** greater than */\n  GREATER_THAN: '>',\n  /** greater than or equal */\n  GREATER_OR_EQUAL: '≽', //\n  LESS_THAN: '<', // less than\n  LESS_OR_EQUAL: '≼', // less than or equal\n  INTERVAL: '<>', // interval\n  INTERVAL_INCLUDE_BOTH: '-', // interval include left and right\n  INTERVAL_INCLUDE_TO: '>-', // interval include right\n  INTERVAL_INCLUDE_FROM: '-<', // interval include left\n  RANGE: '=', // aggegation ranges\n  LIKE: '~', // like\n  CONTAINS: '~' // contains\n};\n\n// ---------------------------------------------------------------------------------\n// ---------------------------------------------------------------------------------\n// ---------------------------------------------------------------------------------\n// ---------------------------------------------------------------------------------\n// ---------------------------------------------------------------------------------\n// ---------------------------------------------------------------------------------\n\nexport interface SearchResponse {\n  hasMoreItems: boolean;\n  numItems: number;\n  totalNumItems: number;\n  objects: CoreApiObject[];\n}\n\n/**\n * Interface providing a search service\n */\nexport interface SearchResult {\n  hasMoreItems: boolean;\n  totalNumItems: number;\n  items: SearchResultItem[];\n  /**\n   * object types within the result\n   */\n\n  objectTypes: string[];\n}\n/**\n * Interface for the item of search results\n */\nexport interface SearchResultItem {\n  objectTypeId: string;\n  content?: SearchResultContent;\n  permissions?: SearchResultPermissions;\n  fields: Map<string, any>;\n}\n\nexport interface SearchResultPermissions {\n  read: Array<'metadata' | 'content'>;\n  write: Array<'metadata' | 'content'>;\n  delete: Array<'object' | 'content'>;\n}\n\nexport type SearchResultContent = ContentStream;\n// /**\n//  * Interface providing search query properties, that can be send to\n//  * the search service\n//  */\n// export interface SearchQueryProperties {\n//   term?: string;\n//   size?: number;\n//   fields?: string[];\n//   from?: number;\n//   aggs?: string[];\n//   maxItems?: number;\n//   types?: string[]; // mixed list of primary and secondary object types\n//   lots?: string[]; // list of leading object types\n//   filters?: any;\n//   hiddenFilters?: any; // hidden filters that will be combined with SearchQuery filters via search service\n//   tableFilters?: any; // table filters that allows to search complex queries\n//   sort?: any;\n//   tags?: any;\n//   scope?: 'all' | 'metadata' | 'content';\n// }\n\n/**\n * Interface providing the estimated result of the current query.\n */\nexport interface AggregateResult {\n  /**\n   * number of results found\n   */\n  totalNumItems: number;\n  aggregations: Aggregation[];\n}\n\n/**\n * Property of a one search query aggregation\n */\nexport interface Aggregation {\n  aggKey: string;\n  entries: {\n    key: string;\n    count: number;\n  }[];\n}\n"]}

package/esm2022/lib/service/search/search.service.mjs

@@ -0,0 +1,178 @@
+import { inject, Injectable } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { BackendService } from '../backend/backend.service';
+import { BaseObjectTypeField, ContentStreamField } from '../system/system.enum';
+import * as i0 from "@angular/core";
+export class SearchService {
+    #backend = inject(BackendService);
+    static { this.DEFAULT_QUERY_SIZE = 50; }
+    /**
+     * Execute a search query ans transform the result to a SearchResult object
+     * @param query The search query
+     * @returns Observable of a SearchResult
+     */
+    search(query) {
+        return this.searchRaw(query).pipe(map((res) => this.toSearchResult(res)));
+    }
+    /**
+     * Execute a raw search query and return the result as is.
+     * @param query The search query
+     * @returns Observable of the raw search result
+     */
+    searchRaw(query) {
+        if (!query.size)
+            query.size = SearchService.DEFAULT_QUERY_SIZE;
+        return this.#backend.post(`/dms/objects/search`, query);
+    }
+    /**
+     * Search for objects in the dms using CMIS like SQL syntax.
+     * @param statement The query statement
+     * @param size The number of items to return
+     * @returns Observable of a SearchResult
+     */
+    searchCmis(statement, size = 50) {
+        return this.#backend
+            .post('/dms/objects/search', {
+            query: {
+                statement,
+                skipCount: 0,
+                maxItems: size,
+                handleDeletedDocuments: 'DELETED_DOCUMENTS_EXCLUDE'
+            }
+        }
+        // Using API-WEB because it enriches the response with additional information (resolved user names, etc.)
+        // ApiBase.core
+        )
+            .pipe(map((res) => this.toSearchResult(res)));
+    }
+    /**
+     * Fetch aggragations for a given query.
+     * @param q The query
+     * @param aggregations List of aggregations to be fetched (e.g. `enaio:objectTypeId`
+     * to get an aggregation of object types)
+     */
+    aggregate(q, aggregations) {
+        q.aggs = aggregations;
+        return this.searchRaw(q).pipe(map((res) => this.#toAggregateResult(res, aggregations)));
+    }
+    /**
+     * Map search result from the backend to applications AggregateResult object
+     * @param searchResponse The backend response
+     * @param aggregations The aggregations to be fetched
+     */
+    #toAggregateResult(searchResponse, aggregations) {
+        const agg = [];
+        if (aggregations) {
+            aggregations.forEach((a) => {
+                const ag = {
+                    aggKey: a,
+                    entries: searchResponse.objects.map((o) => ({
+                        key: o.properties[a].value,
+                        count: o.properties['OBJECT_COUNT'].value
+                    }))
+                };
+                agg.push(ag);
+            });
+        }
+        return {
+            totalNumItems: searchResponse.totalNumItems,
+            aggregations: agg
+        };
+    }
+    /**
+     * Go to a page of a search result.
+     * @param searchResult The search result (that supports pagination)
+     * @param page The number of the page to go to
+     */
+    getPage(query, page) {
+        query.from = (page - 1) * (query.size || SearchService.DEFAULT_QUERY_SIZE);
+        return this.search(query);
+    }
+    /**
+     * Map search result from the backend to applications SearchResult object
+     * @param searchResponse The backend response
+     */
+    toSearchResult(searchResponse) {
+        const resultListItems = [];
+        const objectTypes = [];
+        searchResponse.objects.forEach((o) => {
+            const fields = new Map();
+            // process properties section of result
+            Object.keys(o.properties).forEach((key) => {
+                let value = o.properties[key].value;
+                if (o.properties[key].clvalue) {
+                    // table fields will have a clientValue too ...
+                    value = o.properties[key].clvalue;
+                    // ... and also may contain values that need to be resolved
+                    if (o.properties[key].resolvedValues) {
+                        value.forEach((v) => {
+                            Object.keys(v).forEach((k) => {
+                                const resValue = Array.isArray(v[k]) ? v[k].map((i) => o.properties[key].resolvedValues[i]) : o.properties[key].resolvedValues[v[k]];
+                                if (resValue) {
+                                    v[`${k}_title`] = resValue;
+                                }
+                            });
+                        });
+                    }
+                }
+                fields.set(key, value);
+                if (o.properties[key].title) {
+                    fields.set(key + '_title', o.properties[key].title);
+                }
+            });
+            // process contentStreams section of result if available.
+            // Objects that don't have files attached won't have this section
+            let content;
+            if (o.contentStreams && o.contentStreams.length > 0) {
+                // we assume that each result object only has ONE file attached, altough
+                // this is an array and there may be more
+                const contentStream = o.contentStreams[0];
+                // also add contentstream related fields to the result fields
+                fields.set(ContentStreamField.LENGTH, contentStream.length);
+                fields.set(ContentStreamField.MIME_TYPE, contentStream.mimeType);
+                fields.set(ContentStreamField.FILENAME, contentStream.fileName);
+                fields.set(ContentStreamField.ID, contentStream.contentStreamId);
+                fields.set(ContentStreamField.RANGE, contentStream.contentStreamRange);
+                fields.set(ContentStreamField.REPOSITORY_ID, contentStream.repositoryId);
+                fields.set(ContentStreamField.DIGEST, contentStream.digest);
+                fields.set(ContentStreamField.ARCHIVE_PATH, contentStream.archivePath);
+                content = {
+                    contentStreamId: contentStream.contentStreamId,
+                    repositoryId: contentStream.repositoryId,
+                    range: contentStream.range,
+                    digest: contentStream.digest,
+                    archivePath: contentStream.archivePath,
+                    fileName: contentStream.fileName,
+                    mimeType: contentStream.mimeType,
+                    size: contentStream.length
+                };
+            }
+            const objectTypeId = o.properties[BaseObjectTypeField.OBJECT_TYPE_ID] ? o.properties[BaseObjectTypeField.OBJECT_TYPE_ID].value : null;
+            if (objectTypes.indexOf(objectTypeId) === -1) {
+                objectTypes.push(objectTypeId);
+            }
+            resultListItems.push({
+                objectTypeId,
+                content,
+                fields,
+                permissions: o.permissions
+            });
+        });
+        const result = {
+            hasMoreItems: searchResponse.hasMoreItems,
+            totalNumItems: searchResponse.totalNumItems,
+            items: resultListItems,
+            objectTypes
+        };
+        return result;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SearchService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"search.service.js","sourceRoot":"","sources":["../../../../../../../../libs/yuuvis/client-core/src/lib/service/search/search.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { BackendService } from '../backend/backend.service';\nimport { BaseObjectTypeField, ContentStreamField } from '../system/system.enum';\nimport { AggregateResult, Aggregation, SearchQuery, SearchResponse, SearchResult, SearchResultContent, SearchResultItem } from './search.service.interface';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class SearchService {\n  #backend = inject(BackendService);\n\n  static DEFAULT_QUERY_SIZE = 50;\n\n  /**\n   * Execute a search query ans transform the result to a SearchResult object\n   * @param query The search query\n   * @returns Observable of a SearchResult\n   */\n  search(query: SearchQuery): Observable<SearchResult> {\n    return this.searchRaw(query).pipe(map((res) => this.toSearchResult(res)));\n  }\n\n  /**\n   * Execute a raw search query and return the result as is.\n   * @param query The search query\n   * @returns Observable of the raw search result\n   */\n  searchRaw(query: SearchQuery): Observable<any> {\n    if(!query.size) query.size = SearchService.DEFAULT_QUERY_SIZE;\n    return this.#backend.post(`/dms/objects/search`, query);\n  }\n\n  /**\n   * Search for objects in the dms using CMIS like SQL syntax.\n   * @param statement The query statement\n   * @param size The number of items to return\n   * @returns Observable of a SearchResult\n   */\n  searchCmis(statement: string, size = 50): Observable<SearchResult> {\n    return this.#backend\n      .post(\n        '/dms/objects/search',\n        {\n          query: {\n            statement,\n            skipCount: 0,\n            maxItems: size,\n            handleDeletedDocuments: 'DELETED_DOCUMENTS_EXCLUDE'\n          }\n        }\n        // Using API-WEB because it enriches the response with additional information (resolved user names, etc.)\n        // ApiBase.core\n      )\n      .pipe(map((res) => this.toSearchResult(res as SearchResponse)));\n  }\n\n  /**\n   * Fetch aggragations for a given query.\n   * @param q The query\n   * @param aggregations List of aggregations to be fetched (e.g. `enaio:objectTypeId`\n   * to get an aggregation of object types)\n   */\n  aggregate(q: SearchQuery, aggregations: string[]) {\n    q.aggs = aggregations;\n    return this.searchRaw(q).pipe(map((res) => this.#toAggregateResult(res, aggregations)));\n  }\n\n  /**\n   * Map search result from the backend to applications AggregateResult object\n   * @param searchResponse The backend response\n   * @param aggregations The aggregations to be fetched\n   */\n  #toAggregateResult(searchResponse: any, aggregations?: string[]): AggregateResult {\n    const agg: Aggregation[] = [];\n    if (aggregations) {\n      aggregations.forEach((a) => {\n        const ag: Aggregation = {\n          aggKey: a,\n          entries: searchResponse.objects.map((o: any) => ({\n            key: o.properties[a].value,\n            count: o.properties['OBJECT_COUNT'].value\n          }))\n        };\n        agg.push(ag);\n      });\n    }\n    return {\n      totalNumItems: searchResponse.totalNumItems,\n      aggregations: agg\n    };\n  }\n\n  /**\n   * Go to a page of a search result.\n   * @param searchResult The search result (that supports pagination)\n   * @param page The number of the page to go to\n   */\n  getPage(query: SearchQuery, page: number): Observable<SearchResult> {\n    query.from = (page - 1) * (query.size || SearchService.DEFAULT_QUERY_SIZE);\n    return this.search(query);\n  }\n\n  /**\n   * Map search result from the backend to applications SearchResult object\n   * @param searchResponse The backend response\n   */\n  toSearchResult(searchResponse: SearchResponse): SearchResult {\n    const resultListItems: SearchResultItem[] = [];\n    const objectTypes: string[] = [];\n\n    searchResponse.objects.forEach((o: any) => {\n      const fields = new Map();\n      // process properties section of result\n      Object.keys(o.properties).forEach((key: string) => {\n        let value = o.properties[key].value;\n        if (o.properties[key].clvalue) {\n          // table fields will have a clientValue too ...\n          value = o.properties[key].clvalue;\n          // ... and also may contain values that need to be resolved\n          if (o.properties[key].resolvedValues) {\n            value.forEach((v: any) => {\n              Object.keys(v).forEach((k) => {\n                const resValue = Array.isArray(v[k]) ? v[k].map((i: any) => o.properties[key].resolvedValues[i]) : o.properties[key].resolvedValues[v[k]];\n                if (resValue) {\n                  v[`${k}_title`] = resValue;\n                }\n              });\n            });\n          }\n        }\n\n        fields.set(key, value);\n        if (o.properties[key].title) {\n          fields.set(key + '_title', o.properties[key].title);\n        }\n      });\n\n      // process contentStreams section of result if available.\n      // Objects that don't have files attached won't have this section\n      let content: SearchResultContent | undefined;\n      if (o.contentStreams && o.contentStreams.length > 0) {\n        // we assume that each result object only has ONE file attached, altough\n        // this is an array and there may be more\n        const contentStream = o.contentStreams[0];\n        // also add contentstream related fields to the result fields\n        fields.set(ContentStreamField.LENGTH, contentStream.length);\n        fields.set(ContentStreamField.MIME_TYPE, contentStream.mimeType);\n        fields.set(ContentStreamField.FILENAME, contentStream.fileName);\n        fields.set(ContentStreamField.ID, contentStream.contentStreamId);\n        fields.set(ContentStreamField.RANGE, contentStream.contentStreamRange);\n        fields.set(ContentStreamField.REPOSITORY_ID, contentStream.repositoryId);\n        fields.set(ContentStreamField.DIGEST, contentStream.digest);\n        fields.set(ContentStreamField.ARCHIVE_PATH, contentStream.archivePath);\n\n        content = {\n          contentStreamId: contentStream.contentStreamId,\n          repositoryId: contentStream.repositoryId,\n          range: contentStream.range,\n          digest: contentStream.digest,\n          archivePath: contentStream.archivePath,\n          fileName: contentStream.fileName,\n          mimeType: contentStream.mimeType,\n          size: contentStream.length\n        };\n      }\n\n      const objectTypeId = o.properties[BaseObjectTypeField.OBJECT_TYPE_ID] ? o.properties[BaseObjectTypeField.OBJECT_TYPE_ID].value : null;\n      if (objectTypes.indexOf(objectTypeId) === -1) {\n        objectTypes.push(objectTypeId);\n      }\n\n      resultListItems.push({\n        objectTypeId,\n        content,\n        fields,\n        permissions: o.permissions\n      });\n    });\n\n    const result: SearchResult = {\n      hasMoreItems: searchResponse.hasMoreItems,\n      totalNumItems: searchResponse.totalNumItems,\n      items: resultListItems,\n      objectTypes\n    };\n    return result;\n  }\n}\n"]}

package/esm2022/lib/service/session-storage/session-storage.service.mjs

@@ -0,0 +1,50 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SessionStorageService {
+    #TEMP_STORAGE_ENTRIES_KEY = 'yuv.core.sessionstorage.entries';
+    constructor() {
+        this.#clearTemporaryStorageEntries();
+    }
+    /**
+     * Add a reference to a temporary localstorage entry that should be cleared when a
+     * new browser session starts. In context of forms this will be used to cleanup the
+     * layout state of forms (selected tabs etc.) that are stored locally but should only
+     * be pesisted for one browser session.
+     * @param storageKey Key of the localstorage item
+     */
+    addTemporaryStorageEntry(storageKey) {
+        // entries will themselves be stored in localstorage so we can check for entries
+        // to be removed once the application starts
+        const current = this.#getTemporaryStorageEntries();
+        if (!current.includes(storageKey))
+            localStorage.setItem(this.#TEMP_STORAGE_ENTRIES_KEY, JSON.stringify([...current, storageKey]));
+    }
+    #clearTemporaryStorageEntries() {
+        this.#getTemporaryStorageEntries().forEach((e) => localStorage.removeItem(e));
+        localStorage.removeItem(this.#TEMP_STORAGE_ENTRIES_KEY);
+    }
+    #getTemporaryStorageEntries() {
+        let res = [];
+        const i = localStorage.getItem(this.#TEMP_STORAGE_ENTRIES_KEY);
+        if (i) {
+            try {
+                const entries = JSON.parse(i);
+                if (Array.isArray(entries))
+                    res = entries;
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+        return res;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SessionStorageService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SessionStorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: SessionStorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/service/system/object-form.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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