@imbricate/core 3.10.1 → 3.12.0

package/database/outcome.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Outcome
+ */
+import { IImbricateDocument } from "../document/interface";
+import { DatabaseEditRecord } from "./definition";
+export declare const S_Database_PutSchema_VersionConflict: unique symbol;
+export type ImbricateDatabasePutSchemaOutcomeSymbol = typeof S_Database_PutSchema_VersionConflict;
+export type ImbricateDatabasePutSchemaOutcome = {
+    readonly editRecords: DatabaseEditRecord[];
+} | ImbricateDatabasePutSchemaOutcomeSymbol;
+export declare const S_Database_CreateDocument_IdentifierDuplicated: unique symbol;
+export type ImbricateDatabaseCreateDocumentOutcomeSymbol = typeof S_Database_CreateDocument_IdentifierDuplicated;
+export type ImbricateDatabaseCreateDocumentOutcome = {
+    readonly document: IImbricateDocument;
+} | ImbricateDatabaseCreateDocumentOutcomeSymbol;
+export declare const S_Database_GetDocument_NotFound: unique symbol;
+export type ImbricateDatabaseGetDocumentOutcomeSymbol = typeof S_Database_GetDocument_NotFound;
+export type ImbricateDatabaseGetDocumentOutcome = {
+    readonly document: IImbricateDocument;
+} | ImbricateDatabaseGetDocumentOutcomeSymbol;
+export declare const S_Database_QueryDocuments_Stale: unique symbol;
+export type ImbricateDatabaseQueryDocumentsOutcomeSymbol = typeof S_Database_QueryDocuments_Stale;
+export type ImbricateDatabaseQueryDocumentsOutcome = {
+    readonly documents: IImbricateDocument[];
+} | ImbricateDatabaseQueryDocumentsOutcomeSymbol;
+export declare const S_Database_CountDocuments_Stale: unique symbol;
+export type ImbricateDatabaseCountDocumentsOutcomeSymbol = typeof S_Database_CountDocuments_Stale;
+export type ImbricateDatabaseCountDocumentsOutcome = {
+    readonly count: number;
+} | ImbricateDatabaseCountDocumentsOutcomeSymbol;
+export declare const S_Database_RemoveDocument_NotFound: unique symbol;
+export type ImbricateDatabaseRemoveDocumentOutcomeSymbol = typeof S_Database_RemoveDocument_NotFound;
+export type ImbricateDatabaseRemoveDocumentOutcome = {
+    readonly success: boolean;
+} | ImbricateDatabaseRemoveDocumentOutcomeSymbol;
+export declare const S_Database_PutAnnotation_InvalidNamespace: unique symbol;
+export declare const S_Database_PutAnnotation_InvalidIdentifier: unique symbol;
+export type ImbricateDatabasePutAnnotationOutcomeSymbol = typeof S_Database_PutAnnotation_InvalidNamespace | typeof S_Database_PutAnnotation_InvalidIdentifier;
+export type ImbricateDatabasePutAnnotationOutcome = {
+    readonly editRecords: DatabaseEditRecord[];
+} | ImbricateDatabasePutAnnotationOutcomeSymbol;
+export declare const S_Database_DeleteAnnotation_NotFound: unique symbol;
+export type ImbricateDatabaseDeleteAnnotationOutcomeSymbol = typeof S_Database_DeleteAnnotation_NotFound;
+export type ImbricateDatabaseDeleteAnnotationOutcome = {
+    readonly editRecords: DatabaseEditRecord[];
+} | ImbricateDatabaseDeleteAnnotationOutcomeSymbol;
+export declare const S_Database_AddEditRecords_InvalidEditRecord: unique symbol;
+export type ImbricateDatabaseAddEditRecordsOutcomeSymbol = typeof S_Database_AddEditRecords_InvalidEditRecord;
+export type ImbricateDatabaseAddEditRecordsOutcome = {
+    readonly editRecords: DatabaseEditRecord[];
+} | ImbricateDatabaseAddEditRecordsOutcomeSymbol;
+export declare const S_Database_GetEditRecords_NotFound: unique symbol;
+export type ImbricateDatabaseGetEditRecordsOutcomeSymbol = typeof S_Database_GetEditRecords_NotFound;
+export type ImbricateDatabaseGetEditRecordsOutcome = {
+    readonly editRecords: DatabaseEditRecord[];
+} | ImbricateDatabaseGetEditRecordsOutcomeSymbol;

package/database/outcome.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Database
+ * @description Outcome
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S_Database_GetEditRecords_NotFound = exports.S_Database_AddEditRecords_InvalidEditRecord = exports.S_Database_DeleteAnnotation_NotFound = exports.S_Database_PutAnnotation_InvalidIdentifier = exports.S_Database_PutAnnotation_InvalidNamespace = exports.S_Database_RemoveDocument_NotFound = exports.S_Database_CountDocuments_Stale = exports.S_Database_QueryDocuments_Stale = exports.S_Database_GetDocument_NotFound = exports.S_Database_CreateDocument_IdentifierDuplicated = exports.S_Database_PutSchema_VersionConflict = void 0;
+// Put Schema
+exports.S_Database_PutSchema_VersionConflict = Symbol("Database_PutSchema_VersionConflict");
+// Create Document
+exports.S_Database_CreateDocument_IdentifierDuplicated = Symbol("Database_CreateDocument_IdentifierDuplicated");
+// Get Document
+exports.S_Database_GetDocument_NotFound = Symbol("Database_GetDocument_NotFound");
+// Query Documents
+exports.S_Database_QueryDocuments_Stale = Symbol("Database_QueryDocuments_Stale");
+exports.S_Database_CountDocuments_Stale = Symbol("Database_CountDocuments_Stale");
+// Remove Document
+exports.S_Database_RemoveDocument_NotFound = Symbol("Database_RemoveDocument_NotFound");
+// Put Annotation
+exports.S_Database_PutAnnotation_InvalidNamespace = Symbol("Database_PutAnnotation_InvalidNamespace");
+exports.S_Database_PutAnnotation_InvalidIdentifier = Symbol("Database_PutAnnotation_InvalidIdentifier");
+// Delete Annotation
+exports.S_Database_DeleteAnnotation_NotFound = Symbol("Database_DeleteAnnotation_NotFound");
+// Add Edit Records
+exports.S_Database_AddEditRecords_InvalidEditRecord = Symbol("Database_AddEditRecords_InvalidEditRecord");
+// Get Edit Records
+exports.S_Database_GetEditRecords_NotFound = Symbol("Database_GetEditRecords_NotFound");

package/document/base-class/essential-readonly.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Essential Readonly
+ */
+import { DocumentAnnotations, ImbricateDocumentAuditOptions } from "../definition";
+import { IMBRICATE_DOCUMENT_FEATURE } from "../feature";
+import { IImbricateDocument } from "../interface";
+import { ImbricateDocumentPutPropertyOutcome } from "../outcome";
+import { DocumentProperties, DocumentPropertyKey, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "../property";
+import { ImbricateDocumentEssentialBase } from "./essential";
+export declare abstract class ImbricateDocumentEssentialReadonlyBase extends ImbricateDocumentEssentialBase implements IImbricateDocument {
+    readonly annotations: DocumentAnnotations;
+    readonly supportedFeatures: IMBRICATE_DOCUMENT_FEATURE[];
+    putProperty(_key: DocumentPropertyKey, _value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutPropertyOutcome>;
+    putProperties(_properties: DocumentProperties, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutPropertyOutcome>;
+}

package/document/base-class/essential-readonly.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Essential Readonly
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDocumentEssentialReadonlyBase = void 0;
+const feature_not_supported_1 = require("../../error/document/feature-not-supported");
+const feature_1 = require("../feature");
+const essential_1 = require("./essential");
+class ImbricateDocumentEssentialReadonlyBase extends essential_1.ImbricateDocumentEssentialBase {
+    constructor() {
+        super(...arguments);
+        this.annotations = {};
+        this.supportedFeatures = [];
+    }
+    putProperty(_key, _value, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY);
+    }
+    putProperties(_properties, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY);
+    }
+}
+exports.ImbricateDocumentEssentialReadonlyBase = ImbricateDocumentEssentialReadonlyBase;

package/document/base-class/essential.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Essential
+ */
+import { DocumentAnnotationValue, DocumentAnnotations, DocumentEditRecord, ImbricateDocumentAuditOptions } from "../definition";
+import { IMBRICATE_DOCUMENT_FEATURE } from "../feature";
+import { IImbricateDocument } from "../interface";
+import { ImbricateDocumentAddEditRecordsOutcome, ImbricateDocumentDeleteAnnotationOutcome, ImbricateDocumentGetEditRecordsOutcome, ImbricateDocumentPutAnnotationOutcome } from "../outcome";
+import { ImbricateDocumentFullFeatureBase } from "./full-feature";
+export declare abstract class ImbricateDocumentEssentialBase extends ImbricateDocumentFullFeatureBase implements IImbricateDocument {
+    readonly annotations: DocumentAnnotations;
+    readonly supportedFeatures: IMBRICATE_DOCUMENT_FEATURE[];
+    putAnnotation(_namespace: string, _identifier: string, _value: DocumentAnnotationValue, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutAnnotationOutcome>;
+    deleteAnnotation(_namespace: string, _identifier: string, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentDeleteAnnotationOutcome>;
+    addEditRecords(_records: DocumentEditRecord[]): Promise<ImbricateDocumentAddEditRecordsOutcome>;
+    getEditRecords(): Promise<ImbricateDocumentGetEditRecordsOutcome>;
+}

package/document/base-class/essential.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Essential
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDocumentEssentialBase = void 0;
+const feature_not_supported_1 = require("../../error/document/feature-not-supported");
+const feature_1 = require("../feature");
+const full_feature_1 = require("./full-feature");
+class ImbricateDocumentEssentialBase extends full_feature_1.ImbricateDocumentFullFeatureBase {
+    constructor() {
+        super(...arguments);
+        this.annotations = {};
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY,
+        ];
+    }
+    putAnnotation(_namespace, _identifier, _value, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_ANNOTATION);
+    }
+    deleteAnnotation(_namespace, _identifier, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_DELETE_ANNOTATION);
+    }
+    addEditRecords(_records) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_EDIT_RECORD);
+    }
+    getEditRecords() {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_GET_EDIT_RECORD);
+    }
+}
+exports.ImbricateDocumentEssentialBase = ImbricateDocumentEssentialBase;

package/document/base-class/exclude-annotation.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Exclude Annotation
+ */
+import { DocumentAnnotationValue, DocumentAnnotations, ImbricateDocumentAuditOptions } from "../definition";
+import { IMBRICATE_DOCUMENT_FEATURE } from "../feature";
+import { IImbricateDocument } from "../interface";
+import { ImbricateDocumentDeleteAnnotationOutcome, ImbricateDocumentPutAnnotationOutcome } from "../outcome";
+import { ImbricateDocumentFullFeatureBase } from "./full-feature";
+export declare abstract class ImbricateDocumentExcludeAnnotationBase extends ImbricateDocumentFullFeatureBase implements IImbricateDocument {
+    readonly annotations: DocumentAnnotations;
+    readonly supportedFeatures: IMBRICATE_DOCUMENT_FEATURE[];
+    putAnnotation(_namespace: string, _identifier: string, _value: DocumentAnnotationValue, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutAnnotationOutcome>;
+    deleteAnnotation(_namespace: string, _identifier: string, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentDeleteAnnotationOutcome>;
+}

package/document/base-class/exclude-annotation.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Exclude Annotation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDocumentExcludeAnnotationBase = void 0;
+const feature_not_supported_1 = require("../../error/document/feature-not-supported");
+const feature_1 = require("../feature");
+const full_feature_1 = require("./full-feature");
+class ImbricateDocumentExcludeAnnotationBase extends full_feature_1.ImbricateDocumentFullFeatureBase {
+    constructor() {
+        super(...arguments);
+        this.annotations = {};
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY,
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_EDIT_RECORD,
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_GET_EDIT_RECORD,
+        ];
+    }
+    putAnnotation(_namespace, _identifier, _value, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_ANNOTATION);
+    }
+    deleteAnnotation(_namespace, _identifier, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_DELETE_ANNOTATION);
+    }
+}
+exports.ImbricateDocumentExcludeAnnotationBase = ImbricateDocumentExcludeAnnotationBase;

package/document/base-class/exclude-edit-records.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Exclude Edit Records
+ */
+import { DocumentEditRecord } from "../definition";
+import { IMBRICATE_DOCUMENT_FEATURE } from "../feature";
+import { IImbricateDocument } from "../interface";
+import { ImbricateDocumentAddEditRecordsOutcome, ImbricateDocumentGetEditRecordsOutcome } from "../outcome";
+import { ImbricateDocumentFullFeatureBase } from "./full-feature";
+export declare abstract class ImbricateDocumentExcludeEditRecordsBase extends ImbricateDocumentFullFeatureBase implements IImbricateDocument {
+    readonly supportedFeatures: IMBRICATE_DOCUMENT_FEATURE[];
+    addEditRecords(_records: DocumentEditRecord[]): Promise<ImbricateDocumentAddEditRecordsOutcome>;
+    getEditRecords(): Promise<ImbricateDocumentGetEditRecordsOutcome>;
+}

package/document/base-class/exclude-edit-records.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Exclude Edit Records
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDocumentExcludeEditRecordsBase = void 0;
+const feature_not_supported_1 = require("../../error/document/feature-not-supported");
+const feature_1 = require("../feature");
+const full_feature_1 = require("./full-feature");
+class ImbricateDocumentExcludeEditRecordsBase extends full_feature_1.ImbricateDocumentFullFeatureBase {
+    constructor() {
+        super(...arguments);
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY,
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_ANNOTATION,
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_DELETE_ANNOTATION,
+        ];
+    }
+    addEditRecords(_records) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_EDIT_RECORD);
+    }
+    getEditRecords() {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_GET_EDIT_RECORD);
+    }
+}
+exports.ImbricateDocumentExcludeEditRecordsBase = ImbricateDocumentExcludeEditRecordsBase;

package/document/base-class/full-feature-readonly.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Full Feature Readonly
+ */
+import { DocumentAnnotationValue, DocumentEditRecord, ImbricateDocumentAuditOptions } from "../definition";
+import { IMBRICATE_DOCUMENT_FEATURE } from "../feature";
+import { IImbricateDocument } from "../interface";
+import { ImbricateDocumentAddEditRecordsOutcome, ImbricateDocumentDeleteAnnotationOutcome, ImbricateDocumentPutAnnotationOutcome, ImbricateDocumentPutPropertyOutcome } from "../outcome";
+import { DocumentProperties, DocumentPropertyKey, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "../property";
+import { ImbricateDocumentFullFeatureBase } from "./full-feature";
+export declare abstract class ImbricateDocumentFullFeatureReadonlyBase extends ImbricateDocumentFullFeatureBase implements IImbricateDocument {
+    readonly supportedFeatures: IMBRICATE_DOCUMENT_FEATURE[];
+    putProperty(_key: DocumentPropertyKey, _value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutPropertyOutcome>;
+    putProperties(_properties: DocumentProperties, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutPropertyOutcome>;
+    putAnnotation(_namespace: string, _identifier: string, _value: DocumentAnnotationValue, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutAnnotationOutcome>;
+    deleteAnnotation(_namespace: string, _identifier: string, _auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentDeleteAnnotationOutcome>;
+    addEditRecords(_records: DocumentEditRecord[]): Promise<ImbricateDocumentAddEditRecordsOutcome>;
+}

package/document/base-class/full-feature-readonly.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Full Feature Readonly
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDocumentFullFeatureReadonlyBase = void 0;
+const feature_not_supported_1 = require("../../error/document/feature-not-supported");
+const feature_1 = require("../feature");
+const full_feature_1 = require("./full-feature");
+class ImbricateDocumentFullFeatureReadonlyBase extends full_feature_1.ImbricateDocumentFullFeatureBase {
+    constructor() {
+        super(...arguments);
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_GET_EDIT_RECORD,
+        ];
+    }
+    putProperty(_key, _value, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY);
+    }
+    putProperties(_properties, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY);
+    }
+    putAnnotation(_namespace, _identifier, _value, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_ANNOTATION);
+    }
+    deleteAnnotation(_namespace, _identifier, _auditOptions) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_DELETE_ANNOTATION);
+    }
+    addEditRecords(_records) {
+        throw feature_not_supported_1.ImbricateDocumentFeatureNotSupportedError.withFeature(feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_EDIT_RECORD);
+    }
+}
+exports.ImbricateDocumentFullFeatureReadonlyBase = ImbricateDocumentFullFeatureReadonlyBase;

package/document/base-class/full-feature.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Full Feature
+ */
+import { DocumentAnnotationValue, DocumentAnnotations, DocumentEditRecord, ImbricateDocumentAuditOptions } from "../definition";
+import { IMBRICATE_DOCUMENT_FEATURE } from "../feature";
+import { IImbricateDocument } from "../interface";
+import { ImbricateDocumentAddEditRecordsOutcome, ImbricateDocumentDeleteAnnotationOutcome, ImbricateDocumentGetEditRecordsOutcome, ImbricateDocumentPutAnnotationOutcome, ImbricateDocumentPutPropertyOutcome } from "../outcome";
+import { DocumentProperties, DocumentPropertyKey, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "../property";
+export declare abstract class ImbricateDocumentFullFeatureBase implements IImbricateDocument {
+    abstract readonly uniqueIdentifier: string;
+    abstract readonly documentVersion: string;
+    abstract readonly properties: DocumentProperties;
+    abstract readonly annotations: DocumentAnnotations;
+    readonly supportedFeatures: IMBRICATE_DOCUMENT_FEATURE[];
+    abstract putProperty(key: DocumentPropertyKey, value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>, auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutPropertyOutcome>;
+    abstract putProperties(properties: DocumentProperties, auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutPropertyOutcome>;
+    abstract putAnnotation(namespace: string, identifier: string, value: DocumentAnnotationValue, auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentPutAnnotationOutcome>;
+    abstract deleteAnnotation(namespace: string, identifier: string, auditOptions?: ImbricateDocumentAuditOptions): Promise<ImbricateDocumentDeleteAnnotationOutcome>;
+    abstract addEditRecords(records: DocumentEditRecord[]): Promise<ImbricateDocumentAddEditRecordsOutcome>;
+    abstract getEditRecords(): Promise<ImbricateDocumentGetEditRecordsOutcome>;
+}

package/document/base-class/full-feature.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Full Feature
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImbricateDocumentFullFeatureBase = void 0;
+const feature_1 = require("../feature");
+class ImbricateDocumentFullFeatureBase {
+    constructor() {
+        this.supportedFeatures = [
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_PROPERTY,
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_ANNOTATION,
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_DELETE_ANNOTATION,
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_PUT_EDIT_RECORD,
+            feature_1.IMBRICATE_DOCUMENT_FEATURE.DOCUMENT_GET_EDIT_RECORD,
+        ];
+    }
+}
+exports.ImbricateDocumentFullFeatureBase = ImbricateDocumentFullFeatureBase;

package/document/feature.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Feature
+ */
+export declare enum IMBRICATE_DOCUMENT_FEATURE {
+    DOCUMENT_PUT_PROPERTY = "DOCUMENT_PUT_PROPERTY",
+    DOCUMENT_PUT_ANNOTATION = "DOCUMENT_PUT_ANNOTATION",
+    DOCUMENT_DELETE_ANNOTATION = "DOCUMENT_DELETE_ANNOTATION",
+    DOCUMENT_PUT_EDIT_RECORD = "DOCUMENT_PUT_EDIT_RECORD",
+    DOCUMENT_GET_EDIT_RECORD = "DOCUMENT_GET_EDIT_RECORD"
+}
+export declare const checkImbricateDocumentFeatureSupported: (features: IMBRICATE_DOCUMENT_FEATURE[], feature: IMBRICATE_DOCUMENT_FEATURE) => boolean;

package/document/feature.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Feature
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkImbricateDocumentFeatureSupported = exports.IMBRICATE_DOCUMENT_FEATURE = void 0;
+var IMBRICATE_DOCUMENT_FEATURE;
+(function (IMBRICATE_DOCUMENT_FEATURE) {
+    IMBRICATE_DOCUMENT_FEATURE["DOCUMENT_PUT_PROPERTY"] = "DOCUMENT_PUT_PROPERTY";
+    IMBRICATE_DOCUMENT_FEATURE["DOCUMENT_PUT_ANNOTATION"] = "DOCUMENT_PUT_ANNOTATION";
+    IMBRICATE_DOCUMENT_FEATURE["DOCUMENT_DELETE_ANNOTATION"] = "DOCUMENT_DELETE_ANNOTATION";
+    IMBRICATE_DOCUMENT_FEATURE["DOCUMENT_PUT_EDIT_RECORD"] = "DOCUMENT_PUT_EDIT_RECORD";
+    IMBRICATE_DOCUMENT_FEATURE["DOCUMENT_GET_EDIT_RECORD"] = "DOCUMENT_GET_EDIT_RECORD";
+})(IMBRICATE_DOCUMENT_FEATURE || (exports.IMBRICATE_DOCUMENT_FEATURE = IMBRICATE_DOCUMENT_FEATURE = {}));
+const checkImbricateDocumentFeatureSupported = (features, feature) => {
+    return features.includes(feature);
+};
+exports.checkImbricateDocumentFeatureSupported = checkImbricateDocumentFeatureSupported;

package/document/interface.d.ts

@@ -4,6 +4,8 @@
  * @description Interface
  */
 import { DocumentAnnotationValue, DocumentAnnotations, DocumentEditRecord, ImbricateDocumentAuditOptions } from "./definition";
+import { IMBRICATE_DOCUMENT_FEATURE } from "./feature";
+import { ImbricateDocumentAddEditRecordsOutcome, ImbricateDocumentDeleteAnnotationOutcome, ImbricateDocumentGetEditRecordsOutcome, ImbricateDocumentPutAnnotationOutcome, ImbricateDocumentPutPropertyOutcome } from "./outcome";
 import { DocumentProperties, DocumentPropertyKey, DocumentPropertyValue, IMBRICATE_PROPERTY_TYPE } from "./property";
 export interface IImbricateDocument {
     /**
@@ -13,7 +15,7 @@ export interface IImbricateDocument {
     /**
      * Version of the document draft
      */
-    readonly documentVersion: number;
+    readonly documentVersion: string;
     /**
      * Properties of the document
      */
@@ -22,70 +24,87 @@ export interface IImbricateDocument {
      * Annotations of the database
      */
     readonly annotations: DocumentAnnotations;
+    /**
+     * Supported features of the document
+     */
+    readonly supportedFeatures: IMBRICATE_DOCUMENT_FEATURE[];
     /**
      * Update a property from the document
      *
+     * RequireFeature: DOCUMENT_PUT_PROPERTY
+     *
      * @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.
+     * @returns a promise of the outcome of the put property
+     *  Symbol: S_Document_PutProperty_InvalidKey - if the key is invalid
      */
-    putProperty(key: DocumentPropertyKey, value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<DocumentEditRecord[]>;
+    putProperty(key: DocumentPropertyKey, value: DocumentPropertyValue<IMBRICATE_PROPERTY_TYPE>, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<ImbricateDocumentPutPropertyOutcome>;
     /**
-     * Put and replace all properties of the document
+     * Put and replace all properties of the document, optional
+     *
+     * RequireFeature: DOCUMENT_PUT_PROPERTIES
      *
      * @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.
+     * @returns a promise of the outcome of the put properties
+     *  Symbol: S_Document_PutProperty_InvalidKey - if the key is invalid
      */
-    putProperties(properties: DocumentProperties, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<DocumentEditRecord[]>;
+    putProperties(properties: DocumentProperties, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<ImbricateDocumentPutPropertyOutcome>;
     /**
-     * put annotation to the document
+     * Put annotation to the document, optional
+     *
+     * RequireFeature: DOCUMENT_PUT_ANNOTATION
      *
      * @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
+     * @returns a promise of the outcome of the put annotation
+     *  Symbol: S_Document_PutAnnotation_InvalidNamespace - if the namespace is invalid
+     *  Symbol: S_Document_PutAnnotation_InvalidIdentifier - if the identifier is invalid
      */
-    putAnnotation(namespace: string, identifier: string, value: DocumentAnnotationValue, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<DocumentEditRecord[]>;
+    putAnnotation(namespace: string, identifier: string, value: DocumentAnnotationValue, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<ImbricateDocumentPutAnnotationOutcome>;
     /**
      * Delete annotation from the document
      *
+     * RequireFeature: DOCUMENT_DELETE_ANNOTATION
+     *
      * @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
+     * @returns a promise of the outcome of the delete annotation
+     *  Symbol: S_Document_DeleteAnnotation_NotFound - if the annotation is not found
      */
-    deleteAnnotation(namespace: string, identifier: string, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<DocumentEditRecord[]>;
+    deleteAnnotation(namespace: string, identifier: string, auditOptions?: ImbricateDocumentAuditOptions): PromiseLike<ImbricateDocumentDeleteAnnotationOutcome>;
     /**
      * 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
      *
+     * RequireFeature: DOCUMENT_PUT_EDIT_RECORD
+     *
      * @param records document edit records
+     *
+     * @returns a promise of the outcome of the add edit records
+     *  Symbol: S_Document_AddEditRecords_InvalidRecord - if the record is invalid
      */
-    addEditRecords?(records: DocumentEditRecord[]): PromiseLike<void>;
+    addEditRecords(records: DocumentEditRecord[]): PromiseLike<ImbricateDocumentAddEditRecordsOutcome>;
     /**
      * 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
+     * RequireFeature: DOCUMENT_GET_EDIT_RECORD
+     *
+     * @returns a promise of the outcome of the get edit records
+     *  Symbol: S_Document_GetEditRecords_NotFound - if the edit records are not found
      */
-    getEditRecords?(): PromiseLike<DocumentEditRecord[]>;
+    getEditRecords(): PromiseLike<ImbricateDocumentGetEditRecordsOutcome>;
 }

package/document/outcome.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Outcome
+ */
+import { DocumentEditRecord } from "./definition";
+export declare const S_Document_PutProperty_InvalidKey: unique symbol;
+export type ImbricateDocumentPutPropertyOutcomeSymbol = typeof S_Document_PutProperty_InvalidKey;
+export type ImbricateDocumentPutPropertyOutcome = {
+    readonly editRecords: DocumentEditRecord[];
+} | ImbricateDocumentPutPropertyOutcomeSymbol;
+export declare const S_Document_PutAnnotation_InvalidNamespace: unique symbol;
+export declare const S_Document_PutAnnotation_InvalidIdentifier: unique symbol;
+export type ImbricateDocumentPutAnnotationOutcomeSymbol = typeof S_Document_PutAnnotation_InvalidNamespace | typeof S_Document_PutAnnotation_InvalidIdentifier;
+export type ImbricateDocumentPutAnnotationOutcome = {
+    readonly editRecords: DocumentEditRecord[];
+} | ImbricateDocumentPutAnnotationOutcomeSymbol;
+export declare const S_Document_DeleteAnnotation_NotFound: unique symbol;
+export type ImbricateDocumentDeleteAnnotationOutcomeSymbol = typeof S_Document_DeleteAnnotation_NotFound;
+export type ImbricateDocumentDeleteAnnotationOutcome = {
+    readonly editRecords: DocumentEditRecord[];
+} | ImbricateDocumentDeleteAnnotationOutcomeSymbol;
+export declare const S_Document_AddEditRecords_InvalidRecord: unique symbol;
+export type ImbricateDocumentAddEditRecordsOutcomeSymbol = typeof S_Document_AddEditRecords_InvalidRecord;
+export type ImbricateDocumentAddEditRecordsOutcome = {
+    readonly editRecords: DocumentEditRecord[];
+} | ImbricateDocumentAddEditRecordsOutcomeSymbol;
+export declare const S_Document_GetEditRecords_NotFound: unique symbol;
+export type ImbricateDocumentGetEditRecordsOutcomeSymbol = typeof S_Document_GetEditRecords_NotFound;
+export type ImbricateDocumentGetEditRecordsOutcome = {
+    readonly editRecords: DocumentEditRecord[];
+} | ImbricateDocumentGetEditRecordsOutcomeSymbol;

package/document/outcome.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Document
+ * @description Outcome
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S_Document_GetEditRecords_NotFound = exports.S_Document_AddEditRecords_InvalidRecord = exports.S_Document_DeleteAnnotation_NotFound = exports.S_Document_PutAnnotation_InvalidIdentifier = exports.S_Document_PutAnnotation_InvalidNamespace = exports.S_Document_PutProperty_InvalidKey = void 0;
+// Put Property
+exports.S_Document_PutProperty_InvalidKey = Symbol("Document_PutProperty_InvalidKey");
+// Put Annotation
+exports.S_Document_PutAnnotation_InvalidNamespace = Symbol("Document_PutAnnotation_InvalidNamespace");
+exports.S_Document_PutAnnotation_InvalidIdentifier = Symbol("Document_PutAnnotation_InvalidIdentifier");
+// Delete Annotation
+exports.S_Document_DeleteAnnotation_NotFound = Symbol("Document_DeleteAnnotation_NotFound");
+// Add Edit Records
+exports.S_Document_AddEditRecords_InvalidRecord = Symbol("Document_AddEditRecords_InvalidRecord");
+// Get Edit Records
+exports.S_Document_GetEditRecords_NotFound = Symbol("Document_GetEditRecords_NotFound");

package/document/property/default-value.js

@@ -13,9 +13,9 @@ const getImbricateDefaultValueOfProperty = (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.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 [];

package/document/property.d.ts

@@ -68,4 +68,4 @@ export type DocumentPropertyValueObjectReference = {
     readonly databaseUniqueIdentifier: string;
     readonly documentUniqueIdentifier: string;
 };
-export type DocumentPropertyValueObject<T extends IMBRICATE_PROPERTY_TYPE> = T extends IMBRICATE_PROPERTY_TYPE.BOOLEAN ? boolean : T extends IMBRICATE_PROPERTY_TYPE.STRING ? string : T extends IMBRICATE_PROPERTY_TYPE.NUMBER ? number : T extends IMBRICATE_PROPERTY_TYPE.MARKDOWN ? string : T extends IMBRICATE_PROPERTY_TYPE.JSON ? string : T extends IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT ? string : T extends IMBRICATE_PROPERTY_TYPE.DATE ? string : T extends IMBRICATE_PROPERTY_TYPE.LABEL ? string[] : T extends IMBRICATE_PROPERTY_TYPE.REFERENCE ? DocumentPropertyValueObjectReference[] : never;
+export type DocumentPropertyValueObject<T extends IMBRICATE_PROPERTY_TYPE> = T extends IMBRICATE_PROPERTY_TYPE.BOOLEAN ? boolean : T extends IMBRICATE_PROPERTY_TYPE.STRING ? string : T extends IMBRICATE_PROPERTY_TYPE.NUMBER ? number : T extends IMBRICATE_PROPERTY_TYPE.MARKDOWN ? string[] : T extends IMBRICATE_PROPERTY_TYPE.JSON ? string[] : T extends IMBRICATE_PROPERTY_TYPE.IMBRISCRIPT ? string[] : T extends IMBRICATE_PROPERTY_TYPE.DATE ? string : T extends IMBRICATE_PROPERTY_TYPE.LABEL ? string[] : T extends IMBRICATE_PROPERTY_TYPE.REFERENCE ? DocumentPropertyValueObjectReference[] : never;