@imbricate/core 3.8.0 → 3.8.2

package/database/validate.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Validate
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateImbricateDocumentQuery = void 0;
+const definition_1 = require("./definition");
+/**
+ * Validate imbricate document query
+ *
+ * @param query query to validate
+ *
+ * @returns a string error message if validation failed
+ *        null if validation passed
+ */
+const validateImbricateDocumentQuery = (query) => {
+    if (typeof query !== "object") {
+        return "Query must be an object";
+    }
+    if (query.limit !== undefined && (typeof query.limit !== "number" || query.limit <= 0)) {
+        return "Limit must be a number greater than 0 or undefined";
+    }
+    if (query.skip !== undefined && (typeof query.skip !== "number" || query.skip < 0)) {
+        return "Skip must be a number greater than or equal to 0 or undefined";
+    }
+    if (query.propertyFilters !== undefined) {
+        if (!Array.isArray(query.propertyFilters)) {
+            return "Property filters must be an array";
+        }
+        for (const filter of query.propertyFilters) {
+            if (typeof filter.propertyIdentifier !== "string") {
+                return "Property identifier must be a string";
+            }
+            if (typeof filter.target !== "string"
+                || !Object.values(definition_1.IMBRICATE_QUERY_PROPERTY_CONDITION_TARGET).includes(filter.target)) {
+                return "Target must be a valid target";
+            }
+            if (typeof filter.attribute !== "string"
+                || !Object.values(definition_1.IMBRICATE_QUERY_ATTRIBUTE).includes(filter.attribute)) {
+                return "Attribute must be a valid attribute";
+            }
+            if (typeof filter.condition !== "string"
+                || !Object.values(definition_1.IMBRICATE_QUERY_COMPARE_CONDITION).includes(filter.condition)) {
+                return "Condition must be a valid condition";
+            }
+        }
+    }
+    if (query.annotationFilters !== undefined) {
+        if (!Array.isArray(query.annotationFilters)) {
+            return "Annotation filters must be an array";
+        }
+        for (const filter of query.annotationFilters) {
+            if (typeof filter.namespace !== "string") {
+                return "Namespace must be a string";
+            }
+            if (typeof filter.identifier !== "string") {
+                return "Identifier must be a string";
+            }
+            if (typeof filter.attribute !== "string"
+                || !Object.values(definition_1.IMBRICATE_QUERY_ATTRIBUTE).includes(filter.attribute)) {
+                return "Attribute must be a valid attribute";
+            }
+            if (typeof filter.condition !== "string"
+                || !Object.values(definition_1.IMBRICATE_QUERY_COMPARE_CONDITION).includes(filter.condition)) {
+                return "Condition must be a valid condition";
+            }
+        }
+    }
+    return null;
+};
+exports.validateImbricateDocumentQuery = validateImbricateDocumentQuery;

package/{src/document/definition.ts → document/definition.d.ts}

@@ -3,76 +3,48 @@
  * @namespace Document
  * @description Definition
  */
-
 import { ImbricateAuthor } from "../author/definition";
 import { DocumentPropertyKey, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "./property";
-
 /**
  * Edit record type of the document
  */
-export enum IMBRICATE_DOCUMENT_EDIT_TYPE {
-
+export declare enum IMBRICATE_DOCUMENT_EDIT_TYPE {
     PUT_PROPERTY = "PUT_PROPERTY",
     PUT_ANNOTATION = "PUT_ANNOTATION",
-    DELETE_ANNOTATION = "DELETE_ANNOTATION",
+    DELETE_ANNOTATION = "DELETE_ANNOTATION"
 }
-
 export type DocumentEditOperationValuePutProperty = {
-
     readonly key: DocumentPropertyKey;
     readonly value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>;
 };
-
 export type DocumentEditOperationPutAnnotation = {
-
     readonly annotationNamespace: string;
     readonly annotationIdentifier: string;
-
     readonly data: any;
 };
-
 export type DocumentEditOperationDeleteAnnotation = {
-
     readonly annotationNamespace: string;
     readonly annotationIdentifier: string;
 };
-
-// IMBRICATE_DOCUMENT_EDIT_TYPE SWITCH
-export type DocumentEditOperationValue<T extends IMBRICATE_DOCUMENT_EDIT_TYPE> =
-    T extends IMBRICATE_DOCUMENT_EDIT_TYPE.PUT_PROPERTY ? DocumentEditOperationValuePutProperty :
-    T extends IMBRICATE_DOCUMENT_EDIT_TYPE.PUT_ANNOTATION ? DocumentEditOperationPutAnnotation :
-    T extends IMBRICATE_DOCUMENT_EDIT_TYPE.DELETE_ANNOTATION ? DocumentEditOperationDeleteAnnotation :
-    never;
-
+export type DocumentEditOperationValue<T extends IMBRICATE_DOCUMENT_EDIT_TYPE> = T extends IMBRICATE_DOCUMENT_EDIT_TYPE.PUT_PROPERTY ? DocumentEditOperationValuePutProperty : T extends IMBRICATE_DOCUMENT_EDIT_TYPE.PUT_ANNOTATION ? DocumentEditOperationPutAnnotation : T extends IMBRICATE_DOCUMENT_EDIT_TYPE.DELETE_ANNOTATION ? DocumentEditOperationDeleteAnnotation : never;
 export type DocumentEditOperation<T extends IMBRICATE_DOCUMENT_EDIT_TYPE> = {
-
     readonly action: T;
     readonly value: DocumentEditOperationValue<T>;
 };
-
 export type DocumentEditRecord = {
-
     readonly uniqueIdentifier: string;
     readonly editAt: Date;
-
     readonly operations: Array<DocumentEditOperation<IMBRICATE_DOCUMENT_EDIT_TYPE>>;
-
     readonly author?: ImbricateAuthor;
 };
-
 export type DocumentAnnotations = Record<DocumentAnnotationKey, DocumentAnnotationValue>;
-
 export type DocumentAnnotationKey = string;
 export type DocumentAnnotationValue = {
-
     readonly namespace: string;
     readonly identifier: string;
-
     readonly data: any;
 };
-
 export type ImbricateDocumentAuditOptions = {
-
     /**
      * Do not add edit record, this is controlled an function may vary by origin
      */

package/document/definition.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Definition
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMBRICATE_DOCUMENT_EDIT_TYPE = void 0;
+/**
+ * Edit record type of the document
+ */
+var IMBRICATE_DOCUMENT_EDIT_TYPE;
+(function (IMBRICATE_DOCUMENT_EDIT_TYPE) {
+    IMBRICATE_DOCUMENT_EDIT_TYPE["PUT_PROPERTY"] = "PUT_PROPERTY";
+    IMBRICATE_DOCUMENT_EDIT_TYPE["PUT_ANNOTATION"] = "PUT_ANNOTATION";
+    IMBRICATE_DOCUMENT_EDIT_TYPE["DELETE_ANNOTATION"] = "DELETE_ANNOTATION";
+})(IMBRICATE_DOCUMENT_EDIT_TYPE || (exports.IMBRICATE_DOCUMENT_EDIT_TYPE = IMBRICATE_DOCUMENT_EDIT_TYPE = {}));

package/{src/document/interface.ts → document/interface.d.ts}

@@ -3,113 +3,84 @@
  * @namespace Document
  * @description Interface
  */
-
 import { DocumentAnnotationValue, DocumentAnnotations, DocumentEditRecord, ImbricateDocumentAuditOptions } from "./definition";
 import { DocumentProperties, DocumentPropertyKey, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "./property";
-
 export interface IImbricateDocument {
-
     /**
      * Unique identifier of the database
      */
     readonly uniqueIdentifier: string;
-
     /**
      * Properties of the document
      */
     readonly properties: DocumentProperties;
-
     /**
      * Annotations of the database
      */
     readonly annotations: DocumentAnnotations;
-
     /**
      * Update a property from the document
-     * 
+     *
      * @param key key of the property
      * @param value value of the property
      * @param auditOptions audit options of the document
-     * 
+     *
      * @returns a promise of the edit records of the document
      *  Note: the edit records will not be added to the document if `noEditRecord` is true,
      *  Call `addEditRecords` to add the edit records manually.
      */
-    putProperty(
-        key: DocumentPropertyKey,
-        value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>,
-        auditOptions?: ImbricateDocumentAuditOptions,
-    ): PromiseLike<DocumentEditRecord[]>;
-
+    putProperty(key: DocumentPropertyKey, value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<DocumentEditRecord[]>;
     /**
      * Put and replace all properties of the document
-     * 
+     *
      * @param properties properties of the document
      * @param auditOptions audit options of the document
-     * 
+     *
      * @returns a promise of the edit records of the document
      *  Note: the edit records will not be added to the document if `noEditRecord` is true,
      *  Call `addEditRecords` to add the edit records manually.
      */
-    putProperties(
-        properties: DocumentProperties,
-        auditOptions?: ImbricateDocumentAuditOptions,
-    ): PromiseLike<DocumentEditRecord[]>;
-
+    putProperties(properties: DocumentProperties, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<DocumentEditRecord[]>;
     /**
      * put annotation to the document
-     * 
+     *
      * @param namespace namespace of the annotation
      * @param identifier identifier of the annotation
      * @param value value of the annotation
      * @param auditOptions audit options of the document
-     * 
+     *
      * @returns a promise of the edit records of the document
      *  Note: if the origin supports Document Edit Record, the edit record will be added by default
      *  If you do not want to add the edit record, set `noEditRecord` to true in audit options
      */
-    putAnnotation(
-        namespace: string,
-        identifier: string,
-        value: DocumentAnnotationValue,
-        auditOptions?: ImbricateDocumentAuditOptions,
-    ): PromiseLike<DocumentEditRecord[]>;
-
+    putAnnotation(namespace: string, identifier: string, value: DocumentAnnotationValue, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<DocumentEditRecord[]>;
     /**
      * Delete annotation from the document
-     * 
+     *
      * @param namespace namespace of the annotation
      * @param identifier identifier of the annotation
      * @param auditOptions audit options of the document
-     * 
+     *
      * @returns a promise of the edit records of the document
      *  Note: if the origin supports Document Edit Record, the edit record will be added by default
      *  If you do not want to add the edit record, set `noEditRecord` to true in audit options
      */
-    deleteAnnotation(
-        namespace: string,
-        identifier: string,
-        auditOptions?: ImbricateDocumentAuditOptions,
-    ): PromiseLike<DocumentEditRecord[]>;
-
+    deleteAnnotation(namespace: string, identifier: string, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<DocumentEditRecord[]>;
     /**
      * Add edit records to the document, optional
      *  This method is optional, if not implemented, means the origin
      *  1. The origin does not support edit records
      *  2. The origin force to add edit records when put properties
-     * 
+     *
      * @param records document edit records
      */
-    addEditRecords?(
-        records: DocumentEditRecord[],
-    ): PromiseLike<void>;
-
+    addEditRecords?(records: DocumentEditRecord[]): PromiseLike<void>;
     /**
      * Get edit records of the document, optional
      *  This method is optional, if not implemented, means the origin
      *  1. The origin does not support edit records
      *  2. The origin force to add edit records when put properties
-     * 
+     *
      * @returns a promise of the edit records of the document
      */
     getEditRecords?(): PromiseLike<DocumentEditRecord[]>;

package/document/interface.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Interface
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/document/property/default-value.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @author WMXPY
+ * @namespace Document_Property
+ * @description Default Value
+ */
+import { DocumentPropertyValueObject, IMBRICATE_PROPERTY_TYPE } from "../property";
+export declare const getImbricateDefaultValueOfProperty: (type: IMBRICATE_PROPERTY_TYPE) => DocumentPropertyValueObject<IMBRICATE_PROPERTY_TYPE>;

package/document/property/default-value.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document_Property
+ * @description Default Value
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImbricateDefaultValueOfProperty = void 0;
+const property_1 = require("../property");
+// IMBRICATE_PROPERTY_TYPE SWITCH
+const getImbricateDefaultValueOfProperty = (type) => {
+    switch (type) {
+        case property_1.IMBRICATE_PROPERTY_TYPE.BOOLEAN: return false;
+        case property_1.IMBRICATE_PROPERTY_TYPE.STRING: return "";
+        case property_1.IMBRICATE_PROPERTY_TYPE.NUMBER: return 0;
+        case property_1.IMBRICATE_PROPERTY_TYPE.MARKDOWN: return "";
+        case property_1.IMBRICATE_PROPERTY_TYPE.JSON: return "";
+        case property_1.IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT: return "";
+        case property_1.IMBRICATE_PROPERTY_TYPE.DATE: return new Date().toISOString();
+        case property_1.IMBRICATE_PROPERTY_TYPE.LABEL: return [];
+        case property_1.IMBRICATE_PROPERTY_TYPE.REFERENCE: return [];
+    }
+    return null;
+};
+exports.getImbricateDefaultValueOfProperty = getImbricateDefaultValueOfProperty;

package/{src/document/property/definition.ts → document/property/definition.d.ts}

@@ -3,10 +3,5 @@
  * @namespace Document_Property
  * @description Definition
  */
-
 import { DocumentPropertyKey, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "../property";
-
-export type DocumentPropertyTriageFunction<T extends IMBRICATE_PROPERTY_TYPE, Result> = (
-    propertyKey: DocumentPropertyKey,
-    value: DocumentPropertyValue<T>
-) => Result;
+export type DocumentPropertyTriageFunction<T extends IMBRICATE_PROPERTY_TYPE, Result> = (propertyKey: DocumentPropertyKey, value: DocumentPropertyValue<T>) => Result;

package/document/property/definition.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document_Property
+ * @description Definition
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/document/property/primary.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @author WMXPY
+ * @namespace Document_Property
+ * @description Primary
+ */
+import { ImbricateDatabaseSchema } from "../../database/schema";
+import { DocumentProperties, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "../property";
+export declare const findPrimaryProperty: (schema: ImbricateDatabaseSchema, properties: DocumentProperties) => DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE> | null;

package/document/property/primary.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document_Property
+ * @description Primary
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findPrimaryProperty = void 0;
+const findPrimaryProperty = (schema, properties) => {
+    for (const property of schema.properties) {
+        if (property.isPrimaryKey) {
+            const value = properties[property.propertyIdentifier];
+            if (value) {
+                return value;
+            }
+        }
+    }
+    return null;
+};
+exports.findPrimaryProperty = findPrimaryProperty;

package/document/property/triage-base.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @author WMXPY
+ * @namespace Document_Property
+ * @description Triage Base
+ */
+import { DocumentProperties, DocumentPropertyKey, IMBRICATE_PROPERTY_TYPE } from "../property";
+import { DocumentPropertyTriageFunction } from "./definition";
+export declare class ImbricateDocumentPropertyTriageBase<Result> {
+    private readonly _triageFunctionsByKey;
+    private readonly _triageFunctionsByType;
+    protected constructor();
+    /**
+     * Set triage function for property key,
+     *  This action will override document value based triage functions
+     *
+     * @param propertyKey property key
+     * @param triageFunction triage function
+     * @returns triage manager
+     */
+    forPropertyKey<T extends IMBRICATE_PROPERTY_TYPE>(propertyKey: DocumentPropertyKey, triageFunction: DocumentPropertyTriageFunction<T, Result>): this;
+    forBoolean(triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.BOOLEAN, Result>): this;
+    forString(triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.STRING, Result>): this;
+    forNumber(triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.NUMBER, Result>): this;
+    forMarkdown(triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.MARKDOWN, Result>): this;
+    forJson(triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.JSON, Result>): this;
+    forImbriscript(triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT, Result>): this;
+    forDate(triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.DATE, Result>): this;
+    forLabel(triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.LABEL, Result>): this;
+    forReference(triageFunction: DocumentPropertyTriageFunction<IMBRICATE_PROPERTY_TYPE.REFERENCE, Result>): this;
+    protected _collect(properties: DocumentProperties): Map<DocumentPropertyKey, Result>;
+}

package/document/property/triage-base.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document_Property
+ * @description Triage Base
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDocumentPropertyTriageBase = void 0;
+const property_1 = require("../property");
+// IMBRICATE_PROPERTY_TYPE SWITCH
+class ImbricateDocumentPropertyTriageBase {
+    constructor() {
+        this._triageFunctionsByKey = new Map();
+        this._triageFunctionsByType = new Map();
+    }
+    /**
+     * Set triage function for property key,
+     *  This action will override document value based triage functions
+     *
+     * @param propertyKey property key
+     * @param triageFunction triage function
+     * @returns triage manager
+     */
+    forPropertyKey(propertyKey, triageFunction) {
+        this._triageFunctionsByKey.set(propertyKey, triageFunction);
+        return this;
+    }
+    forBoolean(triageFunction) {
+        this._triageFunctionsByType.set(property_1.IMBRICATE_PROPERTY_TYPE.BOOLEAN, triageFunction);
+        return this;
+    }
+    forString(triageFunction) {
+        this._triageFunctionsByType.set(property_1.IMBRICATE_PROPERTY_TYPE.STRING, triageFunction);
+        return this;
+    }
+    forNumber(triageFunction) {
+        this._triageFunctionsByType.set(property_1.IMBRICATE_PROPERTY_TYPE.NUMBER, triageFunction);
+        return this;
+    }
+    forMarkdown(triageFunction) {
+        this._triageFunctionsByType.set(property_1.IMBRICATE_PROPERTY_TYPE.MARKDOWN, triageFunction);
+        return this;
+    }
+    forJson(triageFunction) {
+        this._triageFunctionsByType.set(property_1.IMBRICATE_PROPERTY_TYPE.JSON, triageFunction);
+        return this;
+    }
+    forImbriscript(triageFunction) {
+        this._triageFunctionsByType.set(property_1.IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT, triageFunction);
+        return this;
+    }
+    forDate(triageFunction) {
+        this._triageFunctionsByType.set(property_1.IMBRICATE_PROPERTY_TYPE.DATE, triageFunction);
+        return this;
+    }
+    forLabel(triageFunction) {
+        this._triageFunctionsByType.set(property_1.IMBRICATE_PROPERTY_TYPE.LABEL, triageFunction);
+        return this;
+    }
+    forReference(triageFunction) {
+        this._triageFunctionsByType.set(property_1.IMBRICATE_PROPERTY_TYPE.REFERENCE, triageFunction);
+        return this;
+    }
+    _collect(properties) {
+        const keys = Object.keys(properties);
+        const result = new Map();
+        for (const key of keys) {
+            const property = properties[key];
+            const triageFunction = this._triageFunctionsByKey.get(key);
+            if (typeof triageFunction === "function") {
+                const value = triageFunction(key, property);
+                result.set(key, value);
+                continue;
+            }
+            const typeFunction = this._triageFunctionsByType.get(property.type);
+            if (typeof typeFunction === "function") {
+                const value = typeFunction(key, property);
+                result.set(key, value);
+                continue;
+            }
+        }
+        return result;
+    }
+}
+exports.ImbricateDocumentPropertyTriageBase = ImbricateDocumentPropertyTriageBase;

package/document/property/triage-manager.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @author WMXPY
+ * @namespace Document_Property
+ * @description Triage Manager
+ */
+import { DocumentProperties, DocumentPropertyKey } from "../property";
+import { ImbricateDocumentPropertyTriageBase } from "./triage-base";
+export declare class ImbricateDocumentPropertyTriageManager<Result> extends ImbricateDocumentPropertyTriageBase<Result> {
+    static create<Result>(properties: DocumentProperties): ImbricateDocumentPropertyTriageManager<Result>;
+    private readonly _properties;
+    private constructor();
+    /**
+     * Collect the result as array
+     *
+     * @returns collected result as array
+     */
+    collectAsArray(): Result[];
+    /**
+     * Collect the result as map
+     *
+     * @returns collected result as map
+     */
+    collectAsMap(): Map<DocumentPropertyKey, Result>;
+    /**
+     * Collect the result as object
+     *
+     * @returns collected result as object
+     */
+    collectAsObject(): Record<DocumentPropertyKey, Result>;
+}

package/document/property/triage-manager.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document_Property
+ * @description Triage Manager
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDocumentPropertyTriageManager = void 0;
+const triage_base_1 = require("./triage-base");
+class ImbricateDocumentPropertyTriageManager extends triage_base_1.ImbricateDocumentPropertyTriageBase {
+    static create(properties) {
+        return new ImbricateDocumentPropertyTriageManager(properties);
+    }
+    constructor(properties) {
+        super();
+        this._properties = properties;
+    }
+    /**
+     * Collect the result as array
+     *
+     * @returns collected result as array
+     */
+    collectAsArray() {
+        const result = super._collect(this._properties);
+        return Array.from(result.values());
+    }
+    /**
+     * Collect the result as map
+     *
+     * @returns collected result as map
+     */
+    collectAsMap() {
+        return super._collect(this._properties);
+    }
+    /**
+     * Collect the result as object
+     *
+     * @returns collected result as object
+     */
+    collectAsObject() {
+        const result = super._collect(this._properties);
+        const keys = Array.from(result.keys());
+        const object = {};
+        for (const key of keys) {
+            object[key] = result.get(key);
+        }
+        return object;
+    }
+}
+exports.ImbricateDocumentPropertyTriageManager = ImbricateDocumentPropertyTriageManager;

package/document/property/triage.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @author WMXPY
+ * @namespace Document_Property
+ * @description Triage
+ */
+import { DocumentProperties } from "../property";
+import { ImbricateDocumentPropertyTriageManager } from "./triage-manager";
+export declare const triageImbricateDocumentProperties: <Result>(properties: DocumentProperties) => ImbricateDocumentPropertyTriageManager<Result>;

package/document/property/triage.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document_Property
+ * @description Triage
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.triageImbricateDocumentProperties = void 0;
+const triage_manager_1 = require("./triage-manager");
+const triageImbricateDocumentProperties = (properties) => {
+    return triage_manager_1.ImbricateDocumentPropertyTriageManager.create(properties);
+};
+exports.triageImbricateDocumentProperties = triageImbricateDocumentProperties;