@imbricate/core 2.6.2 → 3.0.1

package/page/base.d.ts

@@ -1,35 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Page
- * @description Base
- */
-import { ImbricateAuthor } from "../author/definition";
-import { ImbricateCapabilityBuilder } from "../capability/builder";
-import { ImbricateCapability } from "../capability/definition";
-import type { PromiseOr } from "../definition/promise";
-import { ImbricatePageVariant } from "../page-variant/definition";
-import { IMBRICATE_PAGE_CAPABILITY_KEY, ImbricatePageCapability, ImbricatePageHistoryRecord } from "./definition";
-import type { IImbricatePage } from "./interface";
-export declare abstract class ImbricatePageBase implements IImbricatePage {
-    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_PAGE_CAPABILITY_KEY>;
-    static allAllowCapability(): ImbricatePageCapability;
-    static allDenyCapability(): ImbricatePageCapability;
-    abstract readonly title: string;
-    abstract readonly directories: string[];
-    abstract readonly identifier: string;
-    abstract readonly variant: ImbricatePageVariant;
-    abstract readonly digest: string;
-    abstract readonly historyRecords: ImbricatePageHistoryRecord[];
-    abstract readonly description?: string;
-    abstract readonly createdAt: Date;
-    abstract readonly updatedAt: Date;
-    abstract readonly capabilities: ImbricatePageCapability;
-    readContent(): PromiseOr<string>;
-    writeContent(_content: string): PromiseOr<void>;
-    readAttributes(): PromiseOr<Record<string, string>>;
-    writeAttribute(_key: string, _value: string): PromiseOr<void>;
-    refreshUpdateMetadata(_updatedAt: Date, _digest: string, _author: ImbricateAuthor): PromiseOr<void>;
-    refreshUpdatedAt(_updatedAt: Date): PromiseOr<void>;
-    refreshDigest(_digest: string): PromiseOr<void>;
-    addHistoryRecord(_record: ImbricatePageHistoryRecord): PromiseOr<void>;
-}

package/page/base.js

@@ -1,48 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Page
- * @description Base
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricatePageBase = void 0;
-const builder_1 = require("../capability/builder");
-const definition_1 = require("../capability/definition");
-const not_implemented_1 = require("../error/not-implemented");
-const definition_2 = require("./definition");
-class ImbricatePageBase {
-    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
-        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricatePageCapabilityList, initial);
-    }
-    static allAllowCapability() {
-        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
-    }
-    static allDenyCapability() {
-        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
-    }
-    readContent() {
-        throw not_implemented_1.ImbricateNotImplemented.create("ReadContent", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.READ);
-    }
-    writeContent(_content) {
-        throw not_implemented_1.ImbricateNotImplemented.create("WriteContent", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.WRITE);
-    }
-    readAttributes() {
-        throw not_implemented_1.ImbricateNotImplemented.create("ReadAttributes", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.READ_ATTRIBUTE);
-    }
-    writeAttribute(_key, _value) {
-        throw not_implemented_1.ImbricateNotImplemented.create("WriteAttribute", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.WRITE_ATTRIBUTE);
-    }
-    refreshUpdateMetadata(_updatedAt, _digest, _author) {
-        throw not_implemented_1.ImbricateNotImplemented.create("RefreshUpdateMetadata", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_METADATA);
-    }
-    refreshUpdatedAt(_updatedAt) {
-        throw not_implemented_1.ImbricateNotImplemented.create("RefreshUpdatedAt", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_METADATA);
-    }
-    refreshDigest(_digest) {
-        throw not_implemented_1.ImbricateNotImplemented.create("RefreshDigest", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_METADATA);
-    }
-    addHistoryRecord(_record) {
-        throw not_implemented_1.ImbricateNotImplemented.create("AddHistoryRecord", definition_2.IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_HISTORY_RECORD);
-    }
-}
-exports.ImbricatePageBase = ImbricatePageBase;

package/page/definition.d.ts

@@ -1,41 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Page
- * @description Definition
- */
-import { ImbricateAuthor } from "../author/definition";
-import { ImbricateCapability } from "../capability/definition";
-import { ImbricatePageVariant } from "../page-variant/definition";
-import { IMBRICATE_SEARCH_RESULT_TYPE, ImbricateSearchResult, ImbricateSearchSnippet } from "../search/snippet";
-export type ImbricatePageAttributes = Record<string, string>;
-export type ImbricatePageSearchResult = ImbricateSearchResult<IMBRICATE_SEARCH_RESULT_TYPE.PAGE>;
-export type ImbricatePageSearchSnippet = ImbricateSearchSnippet<IMBRICATE_SEARCH_RESULT_TYPE.PAGE>;
-export type ImbricatePageSnapshot = {
-    readonly title: string;
-    readonly directories: string[];
-    readonly identifier: string;
-    readonly variant: ImbricatePageVariant;
-};
-export type ImbricatePageHistoryRecord = {
-    readonly author: ImbricateAuthor;
-    readonly digest: string;
-    readonly updatedAt: Date;
-};
-export type ImbricatePageMetadata = {
-    readonly createdAt: Date;
-    readonly digest: string;
-    readonly updatedAt: Date;
-    readonly attributes: ImbricatePageAttributes;
-    readonly historyRecords: ImbricatePageHistoryRecord[];
-    readonly description?: string;
-} & ImbricatePageSnapshot;
-export type ImbricatePageCapability = Record<IMBRICATE_PAGE_CAPABILITY_KEY, ImbricateCapability>;
-export declare enum IMBRICATE_PAGE_CAPABILITY_KEY {
-    READ = "imbricate.page.read",
-    WRITE = "imbricate.page.write",
-    READ_ATTRIBUTE = "imbricate.page.attribute.read",
-    WRITE_ATTRIBUTE = "imbricate.page.attribute.write",
-    UPDATE_METADATA = "imbricate.page.metadata.update",
-    UPDATE_HISTORY_RECORD = "imbricate.page.history.update"
-}
-export declare const ImbricatePageCapabilityList: IMBRICATE_PAGE_CAPABILITY_KEY[];

package/page/definition.js

@@ -1,25 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Page
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricatePageCapabilityList = exports.IMBRICATE_PAGE_CAPABILITY_KEY = void 0;
-var IMBRICATE_PAGE_CAPABILITY_KEY;
-(function (IMBRICATE_PAGE_CAPABILITY_KEY) {
-    IMBRICATE_PAGE_CAPABILITY_KEY["READ"] = "imbricate.page.read";
-    IMBRICATE_PAGE_CAPABILITY_KEY["WRITE"] = "imbricate.page.write";
-    IMBRICATE_PAGE_CAPABILITY_KEY["READ_ATTRIBUTE"] = "imbricate.page.attribute.read";
-    IMBRICATE_PAGE_CAPABILITY_KEY["WRITE_ATTRIBUTE"] = "imbricate.page.attribute.write";
-    IMBRICATE_PAGE_CAPABILITY_KEY["UPDATE_METADATA"] = "imbricate.page.metadata.update";
-    IMBRICATE_PAGE_CAPABILITY_KEY["UPDATE_HISTORY_RECORD"] = "imbricate.page.history.update";
-})(IMBRICATE_PAGE_CAPABILITY_KEY || (exports.IMBRICATE_PAGE_CAPABILITY_KEY = IMBRICATE_PAGE_CAPABILITY_KEY = {}));
-exports.ImbricatePageCapabilityList = [
-    IMBRICATE_PAGE_CAPABILITY_KEY.READ,
-    IMBRICATE_PAGE_CAPABILITY_KEY.WRITE,
-    IMBRICATE_PAGE_CAPABILITY_KEY.READ_ATTRIBUTE,
-    IMBRICATE_PAGE_CAPABILITY_KEY.WRITE_ATTRIBUTE,
-    IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_METADATA,
-    IMBRICATE_PAGE_CAPABILITY_KEY.UPDATE_HISTORY_RECORD,
-];

package/page/interface.d.ts

@@ -1,55 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Page
- * @description Interface
- */
-import { ImbricateAuthor } from "../author/definition";
-import { PromiseOr } from "../definition/promise";
-import { ImbricatePageVariant } from "../page-variant/definition";
-import { ImbricatePageAttributes, ImbricatePageCapability, ImbricatePageHistoryRecord } from "./definition";
-export interface IImbricatePage {
-    readonly title: string;
-    readonly directories: string[];
-    readonly identifier: string;
-    readonly variant: ImbricatePageVariant;
-    readonly digest: string;
-    readonly historyRecords: ImbricatePageHistoryRecord[];
-    readonly description?: string;
-    readonly createdAt: Date;
-    readonly updatedAt: Date;
-    readonly capabilities: ImbricatePageCapability;
-    readContent(): PromiseOr<string>;
-    writeContent(content: string): PromiseOr<void>;
-    readAttributes(): PromiseOr<ImbricatePageAttributes>;
-    writeAttribute(key: string, value: string): PromiseOr<void>;
-    /**
-     * Refresh Updated At and Digest, and add a history record
-     * Recommended to use this method when updating the page
-     *
-     * @param updatedAt Updated At
-     * @param digest Content Digest
-     * @param author Author
-     */
-    refreshUpdateMetadata(updatedAt: Date, digest: string, author: ImbricateAuthor): PromiseOr<void>;
-    /**
-     * Refresh Updated At
-     * Prefer `refreshUpdateMetadata` in most cases
-     *
-     * @param updatedAt Updated At
-     */
-    refreshUpdatedAt(updatedAt: Date): PromiseOr<void>;
-    /**
-     * Refresh Digest
-     * Prefer `refreshUpdateMetadata` in most cases
-     *
-     * @param digest Content Digest
-     */
-    refreshDigest(digest: string): PromiseOr<void>;
-    /**
-     * Add a history record
-     * Prefer `refreshUpdateMetadata` in most cases
-     *
-     * @param record History Record
-     */
-    addHistoryRecord(record: ImbricatePageHistoryRecord): PromiseOr<void>;
-}

package/page-variant/definition.d.ts

@@ -1,16 +0,0 @@
-/**
- * @author WMXPY
- * @namespace PageVariant
- * @description Definition
- */
-export declare enum IMBRICATE_PAGE_VARIANT_LANGUAGE {
-    TEXT = "text",
-    MARKDOWN = "markdown",
-    LATEX = "latex"
-}
-export declare const IMBRICATE_PAGE_VARIANT_LANGUAGE_LIST: IMBRICATE_PAGE_VARIANT_LANGUAGE[];
-export declare const isValidImbricatePageVariantLanguage: (language: unknown) => language is IMBRICATE_PAGE_VARIANT_LANGUAGE;
-export type ImbricatePageVariant = {
-    readonly language: IMBRICATE_PAGE_VARIANT_LANGUAGE;
-};
-export declare const isImbricatePageVariant: (variant: unknown) => variant is ImbricatePageVariant;

package/page-variant/definition.js

@@ -1,33 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace PageVariant
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImbricatePageVariant = exports.isValidImbricatePageVariantLanguage = exports.IMBRICATE_PAGE_VARIANT_LANGUAGE_LIST = exports.IMBRICATE_PAGE_VARIANT_LANGUAGE = void 0;
-var IMBRICATE_PAGE_VARIANT_LANGUAGE;
-(function (IMBRICATE_PAGE_VARIANT_LANGUAGE) {
-    IMBRICATE_PAGE_VARIANT_LANGUAGE["TEXT"] = "text";
-    IMBRICATE_PAGE_VARIANT_LANGUAGE["MARKDOWN"] = "markdown";
-    IMBRICATE_PAGE_VARIANT_LANGUAGE["LATEX"] = "latex";
-})(IMBRICATE_PAGE_VARIANT_LANGUAGE || (exports.IMBRICATE_PAGE_VARIANT_LANGUAGE = IMBRICATE_PAGE_VARIANT_LANGUAGE = {}));
-exports.IMBRICATE_PAGE_VARIANT_LANGUAGE_LIST = [
-    IMBRICATE_PAGE_VARIANT_LANGUAGE.TEXT,
-    IMBRICATE_PAGE_VARIANT_LANGUAGE.MARKDOWN,
-    IMBRICATE_PAGE_VARIANT_LANGUAGE.LATEX,
-];
-const isValidImbricatePageVariantLanguage = (language) => {
-    return exports.IMBRICATE_PAGE_VARIANT_LANGUAGE_LIST.includes(language);
-};
-exports.isValidImbricatePageVariantLanguage = isValidImbricatePageVariantLanguage;
-const isImbricatePageVariant = (variant) => {
-    if (typeof variant !== "object") {
-        return false;
-    }
-    if (!(0, exports.isValidImbricatePageVariantLanguage)(variant.language)) {
-        return false;
-    }
-    return true;
-};
-exports.isImbricatePageVariant = isImbricatePageVariant;

package/page-variant/extension.d.ts

@@ -1,7 +0,0 @@
-/**
- * @author WMXPY
- * @namespace PageVariant
- * @description Extension
- */
-import { IMBRICATE_PAGE_VARIANT_LANGUAGE } from "./definition";
-export declare const getImbricatePageVariantLanguageExtension: (language: IMBRICATE_PAGE_VARIANT_LANGUAGE, withDot?: boolean) => string;

package/page-variant/extension.js

@@ -1,24 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace PageVariant
- * @description Extension
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getImbricatePageVariantLanguageExtension = void 0;
-const definition_1 = require("./definition");
-const fixExtension = (extension, withDot) => {
-    if (withDot) {
-        return `.${extension}`;
-    }
-    return extension;
-};
-const getImbricatePageVariantLanguageExtension = (language, withDot = true) => {
-    switch (language) {
-        case definition_1.IMBRICATE_PAGE_VARIANT_LANGUAGE.TEXT: return fixExtension("txt", withDot);
-        case definition_1.IMBRICATE_PAGE_VARIANT_LANGUAGE.MARKDOWN: return fixExtension("md", withDot);
-        case definition_1.IMBRICATE_PAGE_VARIANT_LANGUAGE.LATEX: return fixExtension("tex", withDot);
-    }
-    return fixExtension("unknown", withDot);
-};
-exports.getImbricatePageVariantLanguageExtension = getImbricatePageVariantLanguageExtension;

package/query/definition.d.ts

@@ -1,14 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Query
- * @description Definition
- */
-export type ImbricateQueryTime = {
-    readonly before?: Date;
-    readonly after?: Date;
-};
-export type ImbricateQueryString = {
-    readonly equal?: string;
-    readonly include?: string[];
-    readonly exclude?: string[];
-};

package/query/page.d.ts

@@ -1,21 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Query
- * @description Page
- */
-import { ImbricateQueryString, ImbricateQueryTime } from "./definition";
-export type ImbricatePageQuery = {
-    readonly title?: ImbricateQueryString;
-    readonly attributes?: Record<string, ImbricateQueryString>;
-    readonly createdAt?: ImbricateQueryTime;
-    readonly updatedAt?: ImbricateQueryTime;
-};
-export type ImbricateSearchPageConfig = {
-    readonly exact?: boolean;
-    readonly itemLimit?: number;
-    readonly snippetLimit?: number;
-};
-export type ImbricatePageQueryConfig = {
-    readonly limit?: number;
-    readonly skip?: number;
-};

package/query/script.d.ts

@@ -1,21 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Query
- * @description Script
- */
-import { ImbricateQueryString, ImbricateQueryTime } from "./definition";
-export type ImbricateScriptQuery = {
-    readonly scriptName?: ImbricateQueryString;
-    readonly attributes?: Record<string, ImbricateQueryString>;
-    readonly createdAt?: ImbricateQueryTime;
-    readonly updatedAt?: ImbricateQueryTime;
-};
-export type ImbricateSearchScriptConfig = {
-    readonly exact?: boolean;
-    readonly itemLimit?: number;
-    readonly snippetLimit?: number;
-};
-export type ImbricateScriptQueryConfig = {
-    readonly limit?: number;
-    readonly skip?: number;
-};

package/script/base.d.ts

@@ -1,34 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Script
- * @description Base
- */
-import { ImbricateAuthor } from "../author/definition";
-import { ImbricateCapabilityBuilder } from "../capability/builder";
-import { ImbricateCapability } from "../capability/definition";
-import type { PromiseOr } from "../definition/promise";
-import { ImbricateScriptVariant } from "../script-variant/definition";
-import { IMBRICATE_SCRIPT_CAPABILITY_KEY, ImbricateScriptAttributes, ImbricateScriptCapability, ImbricateScriptHistoryRecord } from "./definition";
-import type { IImbricateScript } from "./interface";
-export declare abstract class ImbricateScriptBase implements IImbricateScript {
-    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_SCRIPT_CAPABILITY_KEY>;
-    static allAllowCapability(): ImbricateScriptCapability;
-    static allDenyCapability(): ImbricateScriptCapability;
-    abstract readonly scriptName: string;
-    abstract readonly identifier: string;
-    abstract readonly variant: ImbricateScriptVariant;
-    abstract readonly digest: string;
-    abstract readonly historyRecords: ImbricateScriptHistoryRecord[];
-    abstract readonly description?: string;
-    abstract readonly createdAt: Date;
-    abstract readonly updatedAt: Date;
-    abstract readonly capabilities: ImbricateScriptCapability;
-    readScript(): PromiseOr<string>;
-    writeScript(_script: string): PromiseOr<void>;
-    readAttributes(): PromiseOr<ImbricateScriptAttributes>;
-    writeAttribute(_key: string, _value: string): PromiseOr<void>;
-    refreshUpdateMetadata(_updatedAt: Date, _digest: string, _author: ImbricateAuthor): PromiseOr<void>;
-    refreshUpdatedAt(_updatedAt: Date): PromiseOr<void>;
-    refreshDigest(_digest: string): PromiseOr<void>;
-    addHistoryRecord(_record: ImbricateScriptHistoryRecord): PromiseOr<void>;
-}

package/script/base.js

@@ -1,48 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Script
- * @description Base
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateScriptBase = void 0;
-const builder_1 = require("../capability/builder");
-const definition_1 = require("../capability/definition");
-const not_implemented_1 = require("../error/not-implemented");
-const definition_2 = require("./definition");
-class ImbricateScriptBase {
-    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
-        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateScriptCapabilityList, initial);
-    }
-    static allAllowCapability() {
-        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
-    }
-    static allDenyCapability() {
-        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
-    }
-    readScript() {
-        throw not_implemented_1.ImbricateNotImplemented.create("ReadScript", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.READ);
-    }
-    writeScript(_script) {
-        throw not_implemented_1.ImbricateNotImplemented.create("WriteScript", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.WRITE);
-    }
-    readAttributes() {
-        throw not_implemented_1.ImbricateNotImplemented.create("ReadAttributes", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.READ_ATTRIBUTE);
-    }
-    writeAttribute(_key, _value) {
-        throw not_implemented_1.ImbricateNotImplemented.create("WriteAttribute", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.WRITE_ATTRIBUTE);
-    }
-    refreshUpdateMetadata(_updatedAt, _digest, _author) {
-        throw not_implemented_1.ImbricateNotImplemented.create("RefreshUpdateMetadata", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.UPDATE_METADATA);
-    }
-    refreshUpdatedAt(_updatedAt) {
-        throw not_implemented_1.ImbricateNotImplemented.create("RefreshUpdatedAt", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.UPDATE_METADATA);
-    }
-    refreshDigest(_digest) {
-        throw not_implemented_1.ImbricateNotImplemented.create("RefreshDigest", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.UPDATE_METADATA);
-    }
-    addHistoryRecord(_record) {
-        throw not_implemented_1.ImbricateNotImplemented.create("AddHistoryRecord", definition_2.IMBRICATE_SCRIPT_CAPABILITY_KEY.UPDATE_HISTORY_RECORD);
-    }
-}
-exports.ImbricateScriptBase = ImbricateScriptBase;

package/script/definition.d.ts

@@ -1,41 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Script
- * @description Definition
- */
-import { ImbricateAuthor } from "../author/definition";
-import { ImbricateCapability } from "../capability/definition";
-import { ImbricateScriptVariant } from "../script-variant/definition";
-import { IMBRICATE_SEARCH_RESULT_TYPE, ImbricateSearchResult, ImbricateSearchSnippet } from "../search/snippet";
-export type ImbricateScriptAttributes = Record<string, string>;
-export type ImbricateScriptSearchResult = ImbricateSearchResult<IMBRICATE_SEARCH_RESULT_TYPE.SCRIPT>;
-export type ImbricateScriptSearchSnippet = ImbricateSearchSnippet<IMBRICATE_SEARCH_RESULT_TYPE.SCRIPT>;
-export type ImbricateScriptSnapshot = {
-    readonly scriptName: string;
-    readonly identifier: string;
-    readonly variant: ImbricateScriptVariant;
-};
-export type ImbricateScriptHistoryRecord = {
-    readonly author: ImbricateAuthor;
-    readonly digest: string;
-    readonly updatedAt: Date;
-};
-export type ImbricateScriptMetadata = {
-    readonly createdAt: Date;
-    readonly digest: string;
-    readonly updatedAt: Date;
-    readonly attributes: ImbricateScriptAttributes;
-    readonly historyRecords: ImbricateScriptHistoryRecord[];
-    readonly description?: string;
-} & ImbricateScriptSnapshot;
-export type ImbricateScriptCapability = Record<IMBRICATE_SCRIPT_CAPABILITY_KEY, ImbricateCapability>;
-export declare enum IMBRICATE_SCRIPT_CAPABILITY_KEY {
-    READ = "imbricate.script.read",
-    WRITE = "imbricate.script.write",
-    READ_ATTRIBUTE = "imbricate.script.attribute.read",
-    WRITE_ATTRIBUTE = "imbricate.script.attribute.write",
-    UPDATE_METADATA = "imbricate.script.metadata.update",
-    UPDATE_HISTORY_RECORD = "imbricate.script.history.update",
-    EXECUTE = "imbricate.script.execute"
-}
-export declare const ImbricateScriptCapabilityList: IMBRICATE_SCRIPT_CAPABILITY_KEY[];

package/script/definition.js

@@ -1,27 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Script
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateScriptCapabilityList = exports.IMBRICATE_SCRIPT_CAPABILITY_KEY = void 0;
-var IMBRICATE_SCRIPT_CAPABILITY_KEY;
-(function (IMBRICATE_SCRIPT_CAPABILITY_KEY) {
-    IMBRICATE_SCRIPT_CAPABILITY_KEY["READ"] = "imbricate.script.read";
-    IMBRICATE_SCRIPT_CAPABILITY_KEY["WRITE"] = "imbricate.script.write";
-    IMBRICATE_SCRIPT_CAPABILITY_KEY["READ_ATTRIBUTE"] = "imbricate.script.attribute.read";
-    IMBRICATE_SCRIPT_CAPABILITY_KEY["WRITE_ATTRIBUTE"] = "imbricate.script.attribute.write";
-    IMBRICATE_SCRIPT_CAPABILITY_KEY["UPDATE_METADATA"] = "imbricate.script.metadata.update";
-    IMBRICATE_SCRIPT_CAPABILITY_KEY["UPDATE_HISTORY_RECORD"] = "imbricate.script.history.update";
-    IMBRICATE_SCRIPT_CAPABILITY_KEY["EXECUTE"] = "imbricate.script.execute";
-})(IMBRICATE_SCRIPT_CAPABILITY_KEY || (exports.IMBRICATE_SCRIPT_CAPABILITY_KEY = IMBRICATE_SCRIPT_CAPABILITY_KEY = {}));
-exports.ImbricateScriptCapabilityList = [
-    IMBRICATE_SCRIPT_CAPABILITY_KEY.READ,
-    IMBRICATE_SCRIPT_CAPABILITY_KEY.WRITE,
-    IMBRICATE_SCRIPT_CAPABILITY_KEY.READ_ATTRIBUTE,
-    IMBRICATE_SCRIPT_CAPABILITY_KEY.WRITE_ATTRIBUTE,
-    IMBRICATE_SCRIPT_CAPABILITY_KEY.UPDATE_METADATA,
-    IMBRICATE_SCRIPT_CAPABILITY_KEY.UPDATE_HISTORY_RECORD,
-    IMBRICATE_SCRIPT_CAPABILITY_KEY.EXECUTE,
-];

package/script/interface.d.ts

@@ -1,54 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Script
- * @description Interface
- */
-import { ImbricateAuthor } from "../author/definition";
-import { PromiseOr } from "../definition/promise";
-import { ImbricateScriptVariant } from "../script-variant/definition";
-import { ImbricateScriptAttributes, ImbricateScriptCapability, ImbricateScriptHistoryRecord } from "./definition";
-export interface IImbricateScript {
-    readonly scriptName: string;
-    readonly identifier: string;
-    readonly variant: ImbricateScriptVariant;
-    readonly digest: string;
-    readonly historyRecords: ImbricateScriptHistoryRecord[];
-    readonly description?: string;
-    readonly createdAt: Date;
-    readonly updatedAt: Date;
-    readonly capabilities: ImbricateScriptCapability;
-    readScript(): PromiseOr<string>;
-    writeScript(script: string): PromiseOr<void>;
-    readAttributes(): PromiseOr<ImbricateScriptAttributes>;
-    writeAttribute(key: string, value: string): PromiseOr<void>;
-    /**
-     * Refresh Updated At and Digest, and add a history record
-     * Recommended to use this method when updating the script
-     *
-     * @param updatedAt Updated At
-     * @param digest Content Digest
-     * @param author Author
-     */
-    refreshUpdateMetadata(updatedAt: Date, digest: string, author: ImbricateAuthor): PromiseOr<void>;
-    /**
-     * Refresh Updated At
-     * Prefer `refreshUpdateMetadata` in most cases
-     *
-     * @param updatedAt Updated At
-     */
-    refreshUpdatedAt(updatedAt: Date): PromiseOr<void>;
-    /**
-     * Refresh Digest
-     * Prefer `refreshUpdateMetadata` in most cases
-     *
-     * @param digest Content Digest
-     */
-    refreshDigest(digest: string): PromiseOr<void>;
-    /**
-     * Add a history record
-     * Prefer `refreshUpdateMetadata` in most cases
-     *
-     * @param record History Record
-     */
-    addHistoryRecord(record: ImbricateScriptHistoryRecord): PromiseOr<void>;
-}

package/script-manager/base.d.ts

@@ -1,31 +0,0 @@
-/**
- * @author WMXPY
- * @namespace ScriptManager
- * @description Base
- */
-import { ImbricateAuthor } from "../author/definition";
-import { ImbricateCapabilityBuilder } from "../capability/builder";
-import { ImbricateCapability } from "../capability/definition";
-import type { PromiseOr } from "../definition/promise";
-import { ImbricateScriptQuery, ImbricateScriptQueryConfig, ImbricateSearchScriptConfig } from "../query/script";
-import { IImbricateScriptManager } from "../script-manager/interface";
-import { ImbricateScriptVariant } from "../script-variant/definition";
-import { ImbricateScriptMetadata, ImbricateScriptSearchResult, ImbricateScriptSnapshot } from "../script/definition";
-import { IImbricateScript } from "../script/interface";
-import { IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY, ImbricateScriptManagerCapability } from "./definition";
-export declare abstract class ImbricateScriptManagerBase implements IImbricateScriptManager {
-    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY>;
-    static allAllowCapability(): ImbricateScriptManagerCapability;
-    static allDenyCapability(): ImbricateScriptManagerCapability;
-    abstract readonly capabilities: ImbricateScriptManagerCapability;
-    createScript(_scriptName: string, _variant: ImbricateScriptVariant, _author: ImbricateAuthor, _initialScript: string, _description?: string): PromiseOr<IImbricateScript>;
-    putScript(_scriptMetadata: ImbricateScriptMetadata, _script: string): PromiseOr<IImbricateScript>;
-    renameScript(_identifier: string, _newScriptName: string): PromiseOr<void>;
-    deleteScript(_identifier: string): PromiseOr<void>;
-    hasScript(_scriptName: string): PromiseOr<boolean>;
-    getScript(_identifier: string): PromiseOr<IImbricateScript | null>;
-    listScripts(): PromiseOr<ImbricateScriptSnapshot[]>;
-    searchScripts(_keyword: string, _config: ImbricateSearchScriptConfig): PromiseOr<ImbricateScriptSearchResult[]>;
-    queryScripts(_query: ImbricateScriptQuery, _config: ImbricateScriptQueryConfig): PromiseOr<IImbricateScript[]>;
-    listSupportedVariants(): Promise<ImbricateScriptVariant[]>;
-}

package/script-manager/base.js

@@ -1,54 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace ScriptManager
- * @description Base
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateScriptManagerBase = void 0;
-const builder_1 = require("../capability/builder");
-const definition_1 = require("../capability/definition");
-const not_implemented_1 = require("../error/not-implemented");
-const definition_2 = require("./definition");
-class ImbricateScriptManagerBase {
-    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
-        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateScriptManagerCapabilityList, initial);
-    }
-    static allAllowCapability() {
-        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
-    }
-    static allDenyCapability() {
-        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
-    }
-    createScript(_scriptName, _variant, _author, _initialScript, _description) {
-        throw not_implemented_1.ImbricateNotImplemented.create("CreateScript", definition_2.IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.CREATE_SCRIPT);
-    }
-    putScript(_scriptMetadata, _script) {
-        throw not_implemented_1.ImbricateNotImplemented.create("PutScript", definition_2.IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.PUT_SCRIPT);
-    }
-    renameScript(_identifier, _newScriptName) {
-        throw not_implemented_1.ImbricateNotImplemented.create("RenameScript", definition_2.IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.RENAME_SCRIPT);
-    }
-    deleteScript(_identifier) {
-        throw not_implemented_1.ImbricateNotImplemented.create("DeleteScript", definition_2.IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.DELETE_SCRIPT);
-    }
-    hasScript(_scriptName) {
-        throw not_implemented_1.ImbricateNotImplemented.create("HasScript", definition_2.IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.LIST_SCRIPTS);
-    }
-    getScript(_identifier) {
-        throw not_implemented_1.ImbricateNotImplemented.create("GetScript", definition_2.IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.GET_SCRIPT);
-    }
-    listScripts() {
-        throw not_implemented_1.ImbricateNotImplemented.create("ListScripts", definition_2.IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.LIST_SCRIPTS);
-    }
-    searchScripts(_keyword, _config) {
-        throw not_implemented_1.ImbricateNotImplemented.create("SearchScripts", definition_2.IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.LIST_SCRIPTS);
-    }
-    queryScripts(_query, _config) {
-        throw not_implemented_1.ImbricateNotImplemented.create("QueryScripts", definition_2.IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.LIST_SCRIPTS);
-    }
-    listSupportedVariants() {
-        throw not_implemented_1.ImbricateNotImplemented.create("ListSupportedVariants", definition_2.IMBRICATE_SCRIPT_MANAGER_CAPABILITY_KEY.LIST_SUPPORTED_VARIANTS);
-    }
-}
-exports.ImbricateScriptManagerBase = ImbricateScriptManagerBase;