@imbricate/core 2.6.2 → 3.0.0

package/collection/definition.js

@@ -1,29 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Collection
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateCollectionCapabilityList = exports.IMBRICATE_COLLECTION_CAPABILITY_KEY = void 0;
-var IMBRICATE_COLLECTION_CAPABILITY_KEY;
-(function (IMBRICATE_COLLECTION_CAPABILITY_KEY) {
-    IMBRICATE_COLLECTION_CAPABILITY_KEY["CREATE_PAGE"] = "imbricate.collection.page.create";
-    IMBRICATE_COLLECTION_CAPABILITY_KEY["PUT_PAGE"] = "imbricate.collection.page.put";
-    IMBRICATE_COLLECTION_CAPABILITY_KEY["RETITLE_PAGE"] = "imbricate.collection.page.retitle";
-    IMBRICATE_COLLECTION_CAPABILITY_KEY["DELETE_PAGE"] = "imbricate.collection.page.delete";
-    IMBRICATE_COLLECTION_CAPABILITY_KEY["GET_PAGE"] = "imbricate.collection.page.get";
-    IMBRICATE_COLLECTION_CAPABILITY_KEY["LIST_PAGES"] = "imbricate.collection.page.list";
-    IMBRICATE_COLLECTION_CAPABILITY_KEY["LIST_SUPPORTED_VARIANTS"] = "imbricate.collection.page.list-supported-variants";
-    IMBRICATE_COLLECTION_CAPABILITY_KEY["COLLECTION_OPERATION_MANAGER"] = "imbricate.collection.operation-manager";
-})(IMBRICATE_COLLECTION_CAPABILITY_KEY || (exports.IMBRICATE_COLLECTION_CAPABILITY_KEY = IMBRICATE_COLLECTION_CAPABILITY_KEY = {}));
-exports.ImbricateCollectionCapabilityList = [
-    IMBRICATE_COLLECTION_CAPABILITY_KEY.CREATE_PAGE,
-    IMBRICATE_COLLECTION_CAPABILITY_KEY.PUT_PAGE,
-    IMBRICATE_COLLECTION_CAPABILITY_KEY.RETITLE_PAGE,
-    IMBRICATE_COLLECTION_CAPABILITY_KEY.DELETE_PAGE,
-    IMBRICATE_COLLECTION_CAPABILITY_KEY.GET_PAGE,
-    IMBRICATE_COLLECTION_CAPABILITY_KEY.LIST_PAGES,
-    IMBRICATE_COLLECTION_CAPABILITY_KEY.LIST_SUPPORTED_VARIANTS,
-    IMBRICATE_COLLECTION_CAPABILITY_KEY.COLLECTION_OPERATION_MANAGER,
-];

package/collection/interface.d.ts

@@ -1,43 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Collection
- * @description Interface
- */
-import { ImbricateAuthor } from "../author/definition";
-import { IImbricateCollectionOperationManager } from "../collection-operation-manager/interface";
-import type { PromiseOr } from "../definition/promise";
-import { ImbricatePageVariant } from "../page-variant/definition";
-import type { ImbricatePageMetadata, ImbricatePageSearchResult, ImbricatePageSnapshot } from "../page/definition";
-import type { IImbricatePage } from "../page/interface";
-import type { ImbricatePageQuery, ImbricatePageQueryConfig, ImbricateSearchPageConfig } from "../query/page";
-import type { ImbricateCollectionCapability } from "./definition";
-export interface IImbricateCollection {
-    readonly collectionName: string;
-    readonly uniqueIdentifier: string;
-    readonly description?: string;
-    readonly capabilities: ImbricateCollectionCapability;
-    /**
-     * Create a page
-     *
-     * @param directories Directories
-     * @param title Title
-     * @param variant Variant
-     * @param author Author
-     * @param initialContent Initial content
-     * @param description Description
-     *
-     * @returns Created page
-     */
-    createPage(directories: string[], title: string, variant: ImbricatePageVariant, author: ImbricateAuthor, initialContent: string, description?: string): PromiseOr<IImbricatePage>;
-    putPage(pageMetadata: ImbricatePageMetadata, content: string): PromiseOr<IImbricatePage>;
-    retitlePage(identifier: string, newTitle: string): PromiseOr<void>;
-    deletePage(identifier: string): PromiseOr<void>;
-    hasPage(directories: string[], title: string): PromiseOr<boolean>;
-    getPage(identifier: string): PromiseOr<IImbricatePage | null>;
-    listPages(directories: string[], recursive: boolean): PromiseOr<ImbricatePageSnapshot[]>;
-    listDirectories(directories: string[]): PromiseOr<string[]>;
-    searchPages(keyword: string, config: ImbricateSearchPageConfig): PromiseOr<ImbricatePageSearchResult[]>;
-    queryPages(query: ImbricatePageQuery, config: ImbricatePageQueryConfig): PromiseOr<IImbricatePage[]>;
-    listSupportedVariants(): PromiseOr<ImbricatePageVariant[]>;
-    getOperationManager(): IImbricateCollectionOperationManager;
-}

package/collection/interface.js

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

package/collection/least-common-identifier.d.ts

@@ -1,10 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Collection
- * @description Least Common Identifier
- */
-export type LeastCommonIdentifierItem = {
-    readonly key: string;
-    readonly identifier: string;
-};
-export declare const mapLeastCommonIdentifier: (identifiers: LeastCommonIdentifierItem[]) => Record<string, string>;

package/collection/least-common-identifier.js

@@ -1,54 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Collection
- * @description Least Common Identifier
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapLeastCommonIdentifier = void 0;
-class TrieNode {
-    static create() {
-        return new TrieNode();
-    }
-    constructor() {
-        this._items = [];
-        this._children = {};
-    }
-    get items() {
-        return this._items;
-    }
-    getChild(key) {
-        if (!this._children[key]) {
-            this._children[key] = TrieNode.create();
-        }
-        return this._children[key];
-    }
-    pushItem(item) {
-        this._items.push(item);
-    }
-}
-const mapLeastCommonIdentifier = (identifiers) => {
-    const root = TrieNode.create();
-    for (const identifier of identifiers) {
-        let current = root;
-        for (const char of identifier.identifier) {
-            current.pushItem(identifier.key);
-            current = current.getChild(char);
-        }
-    }
-    const result = {};
-    for (const identifier of identifiers) {
-        let current = root;
-        let currentIdentifier = "";
-        for (const char of identifier.identifier) {
-            current = current.getChild(char);
-            currentIdentifier += char;
-            if (current.items.length === 1) {
-                break;
-            }
-        }
-        result[identifier.key] = currentIdentifier;
-    }
-    return result;
-};
-exports.mapLeastCommonIdentifier = mapLeastCommonIdentifier;

package/collection-manager/base.d.ts

@@ -1,26 +0,0 @@
-/**
- * @author WMXPY
- * @namespace CollectionManager
- * @description Base
- */
-import { ImbricateCapabilityBuilder } from "../capability/builder";
-import { ImbricateCapability } from "../capability/definition";
-import { IImbricateCollection } from "../collection/interface";
-import type { PromiseOr } from "../definition/promise";
-import { ImbricatePageVariant } from "../page-variant/definition";
-import { IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY, ImbricateCollectionManagerCapability } from "./definition";
-import { IImbricateCollectionManager } from "./interface";
-export declare abstract class ImbricateCollectionManagerBase implements IImbricateCollectionManager {
-    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY>;
-    static allAllowCapability(): ImbricateCollectionManagerCapability;
-    static allDenyCapability(): ImbricateCollectionManagerCapability;
-    abstract readonly capabilities: ImbricateCollectionManagerCapability;
-    findSupportedVariants(_variant?: Partial<ImbricatePageVariant>): Promise<ImbricatePageVariant[]>;
-    createCollection(_collectionName: string, _description?: string): PromiseOr<IImbricateCollection>;
-    renameCollection(_collectionUniqueIdentifier: string, _newCollectionName: string): PromiseOr<void>;
-    deleteCollection(_collectionUniqueIdentifier: string): PromiseOr<void>;
-    hasCollection(_collectionName: string): PromiseOr<boolean>;
-    findCollection(_collectionName: string): PromiseOr<IImbricateCollection | null>;
-    getCollection(_collectionUniqueIdentifier: string): PromiseOr<IImbricateCollection | null>;
-    listCollections(): PromiseOr<IImbricateCollection[]>;
-}

package/collection-manager/base.js

@@ -1,59 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace CollectionManager
- * @description Base
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateCollectionManagerBase = 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 ImbricateCollectionManagerBase {
-    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
-        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateCollectionManagerCapabilityList, initial);
-    }
-    static allAllowCapability() {
-        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
-    }
-    static allDenyCapability() {
-        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
-    }
-    findSupportedVariants(_variant) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return [];
-        });
-    }
-    createCollection(_collectionName, _description) {
-        throw not_implemented_1.ImbricateNotImplemented.create("CreateCollection", definition_2.IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY.CREATE_COLLECTION);
-    }
-    renameCollection(_collectionUniqueIdentifier, _newCollectionName) {
-        throw not_implemented_1.ImbricateNotImplemented.create("RenameCollection", definition_2.IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY.RENAME_COLLECTION);
-    }
-    deleteCollection(_collectionUniqueIdentifier) {
-        throw not_implemented_1.ImbricateNotImplemented.create("DeleteCollection", definition_2.IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY.DELETE_COLLECTION);
-    }
-    hasCollection(_collectionName) {
-        throw not_implemented_1.ImbricateNotImplemented.create("HasCollection", definition_2.IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY.LIST_COLLECTIONS);
-    }
-    findCollection(_collectionName) {
-        throw not_implemented_1.ImbricateNotImplemented.create("FindCollection", definition_2.IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY.LIST_COLLECTIONS);
-    }
-    getCollection(_collectionUniqueIdentifier) {
-        throw not_implemented_1.ImbricateNotImplemented.create("GetCollection", definition_2.IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY.GET_COLLECTION);
-    }
-    listCollections() {
-        throw not_implemented_1.ImbricateNotImplemented.create("ListCollections", definition_2.IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY.LIST_COLLECTIONS);
-    }
-}
-exports.ImbricateCollectionManagerBase = ImbricateCollectionManagerBase;

package/collection-manager/definition.d.ts

@@ -1,15 +0,0 @@
-/**
- * @author WMXPY
- * @namespace CollectionManager
- * @description Definition
- */
-import { ImbricateCapability } from "../capability/definition";
-export type ImbricateCollectionManagerCapability = Record<IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY, ImbricateCapability>;
-export declare enum IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY {
-    CREATE_COLLECTION = "imbricate.collection-manager.create",
-    RENAME_COLLECTION = "imbricate.collection-manager.rename",
-    DELETE_COLLECTION = "imbricate.collection-manager.delete",
-    GET_COLLECTION = "imbricate.collection-manager.get",
-    LIST_COLLECTIONS = "imbricate.collection-manager.list"
-}
-export declare const ImbricateCollectionManagerCapabilityList: IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY[];

package/collection-manager/definition.js

@@ -1,23 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace CollectionManager
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateCollectionManagerCapabilityList = exports.IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY = void 0;
-var IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY;
-(function (IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY) {
-    IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY["CREATE_COLLECTION"] = "imbricate.collection-manager.create";
-    IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY["RENAME_COLLECTION"] = "imbricate.collection-manager.rename";
-    IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY["DELETE_COLLECTION"] = "imbricate.collection-manager.delete";
-    IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY["GET_COLLECTION"] = "imbricate.collection-manager.get";
-    IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY["LIST_COLLECTIONS"] = "imbricate.collection-manager.list";
-})(IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY || (exports.IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY = IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY = {}));
-exports.ImbricateCollectionManagerCapabilityList = [
-    IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY.CREATE_COLLECTION,
-    IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY.RENAME_COLLECTION,
-    IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY.DELETE_COLLECTION,
-    IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY.GET_COLLECTION,
-    IMBRICATE_COLLECTION_MANAGER_CAPABILITY_KEY.LIST_COLLECTIONS,
-];

package/collection-manager/interface.d.ts

@@ -1,38 +0,0 @@
-/**
- * @author WMXPY
- * @namespace CollectionManager
- * @description Interface
- */
-import { IImbricateCollection } from "../collection/interface";
-import { PromiseOr } from "../definition/promise";
-import { ImbricatePageVariant } from "../page-variant/definition";
-import { ImbricateCollectionManagerCapability } from "./definition";
-export interface IImbricateCollectionManager {
-    /**
-     * Capabilities of the collection manager
-     */
-    readonly capabilities: ImbricateCollectionManagerCapability;
-    /**
-     * Find supported variants
-     *
-     * @param variant the partial variant to find, if not provided, find all
-     *
-     * @returns supported variants
-     */
-    findSupportedVariants(variant?: Partial<ImbricatePageVariant>): PromiseOr<ImbricatePageVariant[]>;
-    /**
-     * Create a collection
-     *
-     * @param collectionName Collection name
-     * @param description Collection description
-     *
-     * @returns Created collection
-     */
-    createCollection(collectionName: string, description?: string): PromiseOr<IImbricateCollection>;
-    renameCollection(collectionUniqueIdentifier: string, newCollectionName: string): PromiseOr<void>;
-    deleteCollection(collectionUniqueIdentifier: string): PromiseOr<void>;
-    hasCollection(collectionName: string): PromiseOr<boolean>;
-    findCollection(collectionName: string): PromiseOr<IImbricateCollection | null>;
-    getCollection(collectionUniqueIdentifier: string): PromiseOr<IImbricateCollection | null>;
-    listCollections(): PromiseOr<IImbricateCollection[]>;
-}

package/collection-manager/interface.js

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

package/collection-operation-manager/base.d.ts

@@ -1,18 +0,0 @@
-/**
- * @author WMXPY
- * @namespace CollectionOperationManager
- * @description Base
- */
-import { ImbricateCapabilityBuilder } from "../capability/builder";
-import { ImbricateCapability } from "../capability/definition";
-import { IMBRICATE_OPERATION_SCOPE, ImbricateOperation } from "../operation/definition";
-import { IMBRICATE_COLLECTION_OPERATION_MANAGER_CAPABILITY_KEY, ImbricateCollectionOperationManagerCapability } from "./definition";
-import { IImbricateCollectionOperationManager } from "./interface";
-export declare abstract class ImbricateCollectionOperationManagerBase implements IImbricateCollectionOperationManager {
-    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_COLLECTION_OPERATION_MANAGER_CAPABILITY_KEY>;
-    static allAllowCapability(): ImbricateCollectionOperationManagerCapability;
-    static allDenyCapability(): ImbricateCollectionOperationManagerCapability;
-    abstract readonly capabilities: ImbricateCollectionOperationManagerCapability;
-    listOperations(_scope?: IMBRICATE_OPERATION_SCOPE): Promise<Array<ImbricateOperation<IMBRICATE_OPERATION_SCOPE>>>;
-    executeOperation(_operationIdentifier: string, _parameter: unknown): Promise<void>;
-}

package/collection-operation-manager/base.js

@@ -1,43 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace CollectionOperationManager
- * @description Base
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateCollectionOperationManagerBase = 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 ImbricateCollectionOperationManagerBase {
-    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
-        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateCollectionOperationManagerCapabilityList, initial);
-    }
-    static allAllowCapability() {
-        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
-    }
-    static allDenyCapability() {
-        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
-    }
-    listOperations(_scope) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw not_implemented_1.ImbricateNotImplemented.create("ListOperations", definition_2.IMBRICATE_COLLECTION_OPERATION_MANAGER_CAPABILITY_KEY.LIST_OPERATIONS);
-        });
-    }
-    executeOperation(_operationIdentifier, _parameter) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw not_implemented_1.ImbricateNotImplemented.create("ExecuteOperation", definition_2.IMBRICATE_COLLECTION_OPERATION_MANAGER_CAPABILITY_KEY.EXECUTE_OPERATION);
-        });
-    }
-}
-exports.ImbricateCollectionOperationManagerBase = ImbricateCollectionOperationManagerBase;

package/collection-operation-manager/definition.d.ts

@@ -1,12 +0,0 @@
-/**
- * @author WMXPY
- * @namespace CollectionOperationManager
- * @description Definition
- */
-import { ImbricateCapability } from "../capability/definition";
-export type ImbricateCollectionOperationManagerCapability = Record<IMBRICATE_COLLECTION_OPERATION_MANAGER_CAPABILITY_KEY, ImbricateCapability>;
-export declare enum IMBRICATE_COLLECTION_OPERATION_MANAGER_CAPABILITY_KEY {
-    LIST_OPERATIONS = "imbricate.collection-operation.list",
-    EXECUTE_OPERATION = "imbricate.collection-operation.execute"
-}
-export declare const ImbricateCollectionOperationManagerCapabilityList: IMBRICATE_COLLECTION_OPERATION_MANAGER_CAPABILITY_KEY[];

package/collection-operation-manager/definition.js

@@ -1,17 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace CollectionOperationManager
- * @description Definition
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateCollectionOperationManagerCapabilityList = exports.IMBRICATE_COLLECTION_OPERATION_MANAGER_CAPABILITY_KEY = void 0;
-var IMBRICATE_COLLECTION_OPERATION_MANAGER_CAPABILITY_KEY;
-(function (IMBRICATE_COLLECTION_OPERATION_MANAGER_CAPABILITY_KEY) {
-    IMBRICATE_COLLECTION_OPERATION_MANAGER_CAPABILITY_KEY["LIST_OPERATIONS"] = "imbricate.collection-operation.list";
-    IMBRICATE_COLLECTION_OPERATION_MANAGER_CAPABILITY_KEY["EXECUTE_OPERATION"] = "imbricate.collection-operation.execute";
-})(IMBRICATE_COLLECTION_OPERATION_MANAGER_CAPABILITY_KEY || (exports.IMBRICATE_COLLECTION_OPERATION_MANAGER_CAPABILITY_KEY = IMBRICATE_COLLECTION_OPERATION_MANAGER_CAPABILITY_KEY = {}));
-exports.ImbricateCollectionOperationManagerCapabilityList = [
-    IMBRICATE_COLLECTION_OPERATION_MANAGER_CAPABILITY_KEY.LIST_OPERATIONS,
-    IMBRICATE_COLLECTION_OPERATION_MANAGER_CAPABILITY_KEY.EXECUTE_OPERATION,
-];

package/collection-operation-manager/interface.d.ts

@@ -1,34 +0,0 @@
-/**
- * @author WMXPY
- * @namespace CollectionOperationManager
- * @description Interface
- */
-import { PromiseOr } from "../definition/promise";
-import { IMBRICATE_OPERATION_SCOPE, ImbricateOperation, ImbricateOperationParameter } from "../operation/definition";
-import { ImbricateCollectionOperationManagerCapability } from "./definition";
-export interface IImbricateCollectionOperationManager {
-    /**
-     * Capabilities of the origin operation manager
-     */
-    readonly capabilities: ImbricateCollectionOperationManagerCapability;
-    /**
-     * List all operations
-     *
-     * @returns all operations
-     */
-    listOperations(): PromiseOr<Array<ImbricateOperation<IMBRICATE_OPERATION_SCOPE>>>;
-    /**
-     * List operations by scope
-     *
-     * @param scope the scope of the operation
-     * @returns all operations
-     */
-    listOperations<T extends IMBRICATE_OPERATION_SCOPE>(scope: IMBRICATE_OPERATION_SCOPE): PromiseOr<Array<ImbricateOperation<T>>>;
-    /**
-     * Execute operation by identifier
-     *
-     * @param operationIdentifier the identifier of the operation
-     * @param parameter the parameter of the operation
-     */
-    executeOperation<T extends IMBRICATE_OPERATION_SCOPE>(operationIdentifier: string, parameter: ImbricateOperationParameter<T>): PromiseOr<void>;
-}

package/collection-operation-manager/interface.js

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

package/definition/listable.d.ts

@@ -1,6 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Definition
- * @description Listable
- */
-export type ListableValue<T> = T | T[];

package/definition/listable.js

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

package/definition/promise.d.ts

@@ -1,6 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Definition
- * @description Promise
- */
-export type PromiseOr<T> = T | PromiseLike<T>;

package/error/imbricate-error.d.ts

@@ -1,15 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Error
- * @description Imbricate
- */
-export declare class ImbricateError extends Error {
-    private readonly _type;
-    private readonly _message;
-    private readonly _reason;
-    protected constructor(message: string, type: string, reason?: any);
-    get type(): string;
-    get message(): string;
-    get reason(): any | undefined;
-    toString(): string;
-}

package/error/imbricate-error.js

@@ -1,30 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Error
- * @description Imbricate
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateError = void 0;
-class ImbricateError extends Error {
-    constructor(message, type, reason) {
-        super(message);
-        this._type = type;
-        this._message = message;
-        this._reason = reason;
-        Object.setPrototypeOf(this, ImbricateError.prototype);
-    }
-    get type() {
-        return this._type;
-    }
-    get message() {
-        return this._message;
-    }
-    get reason() {
-        return this._reason;
-    }
-    toString() {
-        return `[${this._type}] ${this.message}`;
-    }
-}
-exports.ImbricateError = ImbricateError;

package/error/not-implemented.d.ts

@@ -1,10 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Error
- * @description Not Implemented
- */
-import { ImbricateError } from "./imbricate-error";
-export declare class ImbricateNotImplemented extends ImbricateError {
-    static create(feature: string, capabilityIdentifier: string): ImbricateNotImplemented;
-    protected constructor(message: string, reason?: any);
-}

package/error/not-implemented.js

@@ -1,19 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace Error
- * @description Not Implemented
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateNotImplemented = void 0;
-const imbricate_error_1 = require("./imbricate-error");
-class ImbricateNotImplemented extends imbricate_error_1.ImbricateError {
-    static create(feature, capabilityIdentifier) {
-        return new ImbricateNotImplemented(`Feature: [${feature}], which correspond with capability: [${capabilityIdentifier}] is not Implemented`);
-    }
-    constructor(message, reason) {
-        super(message, "ImbricateNotImplemented", reason);
-        Object.setPrototypeOf(this, ImbricateNotImplemented.prototype);
-    }
-}
-exports.ImbricateNotImplemented = ImbricateNotImplemented;

package/executable-manager/base.d.ts

@@ -1,21 +0,0 @@
-/**
- * @author WMXPY
- * @namespace ExecutableManager
- * @description Base
- */
-import { ImbricateCapabilityBuilder } from "../capability/builder";
-import { ImbricateCapability } from "../capability/definition";
-import { ImbricateExecuteEnvironment, ImbricateExecuteParameters, ImbricateExecuteResult } from "../execute/definition";
-import { ImbricateScriptVariant } from "../script-variant/definition";
-import { IImbricateScript } from "../script/interface";
-import { IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY, ImbricateExecutableManagerCapability } from "./definition";
-import { IImbricateExecutableManager } from "./interface";
-export declare abstract class ImbricateExecutableManagerBase implements IImbricateExecutableManager {
-    static buildCapability(initial?: ImbricateCapability): ImbricateCapabilityBuilder<IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY>;
-    static allAllowCapability(): ImbricateExecutableManagerCapability;
-    static allDenyCapability(): ImbricateExecutableManagerCapability;
-    abstract readonly capabilities: ImbricateExecutableManagerCapability;
-    findSupportedVariants(_variant?: Partial<ImbricateScriptVariant>): Promise<ImbricateScriptVariant[]>;
-    executeScript(_script: IImbricateScript, _parameters: ImbricateExecuteParameters, _environment: ImbricateExecuteEnvironment): Promise<ImbricateExecuteResult>;
-    executeSnippet(_snippet: string, _variant: ImbricateScriptVariant, _parameters: ImbricateExecuteParameters, _environment: ImbricateExecuteEnvironment): Promise<ImbricateExecuteResult>;
-}

package/executable-manager/base.js

@@ -1,44 +0,0 @@
-"use strict";
-/**
- * @author WMXPY
- * @namespace ExecutableManager
- * @description Base
- */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImbricateExecutableManagerBase = 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 ImbricateExecutableManagerBase {
-    static buildCapability(initial = (0, definition_1.createDenyImbricateCapability)()) {
-        return builder_1.ImbricateCapabilityBuilder.create(definition_2.ImbricateExecutableManagerCapabilityList, initial);
-    }
-    static allAllowCapability() {
-        return this.buildCapability((0, definition_1.createAllowImbricateCapability)()).build();
-    }
-    static allDenyCapability() {
-        return this.buildCapability((0, definition_1.createDenyImbricateCapability)()).build();
-    }
-    findSupportedVariants(_variant) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return [];
-        });
-    }
-    executeScript(_script, _parameters, _environment) {
-        throw not_implemented_1.ImbricateNotImplemented.create("ExecuteScript", definition_2.IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY.EXECUTE_SCRIPT);
-    }
-    executeSnippet(_snippet, _variant, _parameters, _environment) {
-        throw not_implemented_1.ImbricateNotImplemented.create("ExecuteSnippet", definition_2.IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY.EXECUTE_SNIPPET);
-    }
-}
-exports.ImbricateExecutableManagerBase = ImbricateExecutableManagerBase;

package/executable-manager/definition.d.ts

@@ -1,12 +0,0 @@
-/**
- * @author WMXPY
- * @namespace ExecutableManager
- * @description Definition
- */
-import { ImbricateCapability } from "../capability/definition";
-export type ImbricateExecutableManagerCapability = Record<IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY, ImbricateCapability>;
-export declare enum IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY {
-    EXECUTE_SCRIPT = "imbricate.executable-manager.execute-script",
-    EXECUTE_SNIPPET = "imbricate.executable-manager.execute-snippet"
-}
-export declare const ImbricateExecutableManagerCapabilityList: IMBRICATE_EXECUTABLE_MANAGER_CAPABILITY_KEY[];