@imbricate/core 0.1.0 → 1.0.1

package/definition/listable.d.ts

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

package/definition/listable.js

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

package/definition/promise.d.ts

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

package/definition/promise.js

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

package/definition/script.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @author WMXPY
+ * @namespace Definition
+ * @description Script
+ */
+export type ImbricateScriptMetadata = {
+    readonly scriptName: string;
+    readonly identifier: string;
+};

package/definition/script.js

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

package/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @author WMXPY
+ * @description Index
+ */
+export * from "./definition/listable";
+export * from "./definition/promise";
+export * from "./definition/script";
+export * from "./origin/collection/interface";
+export * from "./origin/collection/least-common-identifier";
+export * from "./origin/interface";
+export * from "./sandbox/feature/builder";
+export * from "./sandbox/feature/feature";
+export * from "./sandbox/sandbox";
+export * from "./search/prefix";
+export * from "./search/snippet";

package/index.js

@@ -1,8 +1,31 @@
+"use strict";
 /**
  * @author WMXPY
  * @description Index
  */
-export * from "./builder/interface";
-export * from "./schema/interface";
-export * from "./util/writable";
-export * from "./verify/interface";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./definition/listable"), exports);
+__exportStar(require("./definition/promise"), exports);
+__exportStar(require("./definition/script"), exports);
+__exportStar(require("./origin/collection/interface"), exports);
+__exportStar(require("./origin/collection/least-common-identifier"), exports);
+__exportStar(require("./origin/interface"), exports);
+__exportStar(require("./sandbox/feature/builder"), exports);
+__exportStar(require("./sandbox/feature/feature"), exports);
+__exportStar(require("./sandbox/sandbox"), exports);
+__exportStar(require("./search/prefix"), exports);
+__exportStar(require("./search/snippet"), exports);

package/origin/collection/interface.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @author WMXPY
+ * @namespace Origin_Collection
+ * @description Interface
+ */
+import { IMBRICATE_SEARCH_SNIPPET_TYPE, ImbricateSearchSnippet } from "../../search/snippet";
+export type ImbricateOriginCollectionListPagesResponse = {
+    readonly title: string;
+    readonly identifier: string;
+};
+export interface IImbricateOriginCollection {
+    readonly collectionName: string;
+    readonly description?: string;
+    findScripts(...onActivities: string[]): Promise<void>;
+    listPages(): Promise<ImbricateOriginCollectionListPagesResponse[]>;
+    createPage(title: string, initialContent?: string): Promise<ImbricateOriginCollectionListPagesResponse>;
+    deletePage(identifier: string, title: string): Promise<void>;
+    openPage(title: string): Promise<void>;
+    readPage(identifier: string): Promise<string>;
+    hasPage(title: string): Promise<boolean>;
+    searchPages(keyword: string): Promise<Array<ImbricateSearchSnippet<IMBRICATE_SEARCH_SNIPPET_TYPE.PAGE>>>;
+}

package/origin/collection/interface.js

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

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

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

package/origin/collection/least-common-identifier.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Origin_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/origin/interface.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @author WMXPY
+ * @namespace Origin
+ * @description Interface
+ */
+import { MarkedResult } from "@sudoo/marked";
+import { PromiseOr } from "../definition/promise";
+import { ImbricateScriptMetadata } from "../definition/script";
+import { SandboxExecuteConfig } from "../sandbox/definition/config";
+import { IImbricateOriginCollection } from "./collection/interface";
+export type ImbricateOriginMetadata = {
+    readonly type: string;
+};
+export interface IImbricateOrigin {
+    readonly metadata: ImbricateOriginMetadata;
+    readonly payloads: Record<string, any>;
+    createCollection(collectionName: string, description?: string): PromiseOr<void>;
+    hasCollection(collectionName: string): PromiseOr<boolean>;
+    getCollection(collectionName: string): PromiseOr<IImbricateOriginCollection | null>;
+    listCollections(): PromiseOr<IImbricateOriginCollection[]>;
+    removeCollection(): PromiseOr<void>;
+    createScript(scriptName: string, description?: string): PromiseOr<ImbricateScriptMetadata>;
+    hasScript(scriptName: string): PromiseOr<boolean>;
+    getScript(scriptIdentifier: string): PromiseOr<string | null>;
+    openScript(scriptIdentifier: string): PromiseOr<string>;
+    listScripts(): PromiseOr<ImbricateScriptMetadata[]>;
+    removeScript(scriptIdentifier: string, scriptName: string): PromiseOr<void>;
+    executeScript(scriptIdentifier: string, config: SandboxExecuteConfig): PromiseOr<MarkedResult | null>;
+}

package/origin/interface.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@imbricate/core",
   "main": "index.js",
-  "version": "0.1.0",
+  "version": "1.0.1",
   "description": "Core for Imbricate",
   "repository": {
     "type": "git",
@@ -15,5 +15,13 @@
   "bugs": {
     "url": "https://github.com/Imbricate/Imbricate-Core/issues"
   },
-  "homepage": "https://imbricate.io"
+  "homepage": "https://imbricate.io",
+  "dependencies": {
+    "@sudoo/marked": "^3.21.4",
+    "@sudoo/marked-mixin-date": "^1.0.0",
+    "@sudoo/marked-mixin-json": "^1.0.0",
+    "@sudoo/marked-mixin-math": "^1.4.0",
+    "@sudoo/marked-mixin-object": "^1.3.0",
+    "@sudoo/marked-mixin-parse": "^1.0.0"
+  }
 }

package/sandbox/definition/config.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @author WMXPY
+ * @namespace Sandbox_Definition
+ * @description Config
+ */
+export type SandboxExecuteConfig = Record<string, any>;

package/sandbox/definition/config.js

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

package/sandbox/definition/environment.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @author WMXPY
+ * @namespace Sandbox_Definition
+ * @description Environment
+ */
+export type SandboxEnvironmentOrigin = {
+    readonly type: string;
+};
+export type SandboxEnvironment = {
+    readonly origin: SandboxEnvironmentOrigin;
+};

package/sandbox/definition/environment.js

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

package/sandbox/definition/implementation.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @author WMXPY
+ * @namespace Sandbox_Definition
+ * @description Implementation
+ */
+export type SandboxImplementation = (...args: any[]) => Promise<any> | any;

package/sandbox/definition/implementation.js

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

package/sandbox/feature/builder.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @author WMXPY
+ * @namespace Sandbox_Feature
+ * @description Builder
+ */
+import { SandboxImplementation } from "../definition/implementation";
+import { SandboxFeature } from "./feature";
+export declare class SandboxFeatureBuilder {
+    static fromScratch(): SandboxFeatureBuilder;
+    private _packageName;
+    private _methodName;
+    private _implementation;
+    private constructor();
+    withPackageName(packageName: string): this;
+    withMethodName(methodName: string): this;
+    withImplementation(implementation: SandboxImplementation): this;
+    build(): SandboxFeature;
+}

package/sandbox/feature/builder.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Sandbox_Feature
+ * @description Builder
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxFeatureBuilder = void 0;
+const feature_1 = require("./feature");
+class SandboxFeatureBuilder {
+    static fromScratch() {
+        return new SandboxFeatureBuilder();
+    }
+    constructor() {
+        this._packageName = "";
+        this._methodName = "";
+        this._implementation = () => null;
+    }
+    withPackageName(packageName) {
+        this._packageName = packageName;
+        return this;
+    }
+    withMethodName(methodName) {
+        this._methodName = methodName;
+        return this;
+    }
+    withImplementation(implementation) {
+        this._implementation = implementation;
+        return this;
+    }
+    build() {
+        return feature_1.SandboxFeature.create(this._packageName, this._methodName, this._implementation);
+    }
+}
+exports.SandboxFeatureBuilder = SandboxFeatureBuilder;

package/sandbox/feature/feature.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @author WMXPY
+ * @namespace Sandbox_Feature
+ * @description Feature
+ */
+import { SandboxImplementation } from "../definition/implementation";
+export declare class SandboxFeature {
+    static create(packageName: string, methodName: string, implementation: SandboxImplementation): SandboxFeature;
+    private readonly _packageName;
+    private readonly _methodName;
+    private readonly _implementation;
+    private constructor();
+    get packageName(): string;
+    get methodName(): string;
+    get implementation(): SandboxImplementation;
+}

package/sandbox/feature/feature.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Sandbox_Feature
+ * @description Feature
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SandboxFeature = void 0;
+class SandboxFeature {
+    static create(packageName, methodName, implementation) {
+        return new SandboxFeature(packageName, methodName, implementation);
+    }
+    constructor(packageName, methodName, implementation) {
+        this._packageName = packageName;
+        this._methodName = methodName;
+        this._implementation = implementation;
+    }
+    get packageName() {
+        return this._packageName;
+    }
+    get methodName() {
+        return this._methodName;
+    }
+    get implementation() {
+        return this._implementation;
+    }
+}
+exports.SandboxFeature = SandboxFeature;

package/sandbox/provide/feature.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @author WMXPY
+ * @namespace Sandbox_Provide
+ * @description Feature
+ */
+import { Sandbox } from "@sudoo/marked";
+import { SandboxFeature } from "../feature/feature";
+export declare const sandboxProvideFeatures: (sandbox: Sandbox, features: SandboxFeature[]) => void;

package/sandbox/provide/feature.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Sandbox_Provide
+ * @description Feature
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sandboxProvideFeatures = void 0;
+const mapFeatures = (features) => {
+    const map = {};
+    for (const feature of features) {
+        if (!map[feature.packageName]) {
+            map[feature.packageName] = {};
+        }
+        map[feature.packageName][feature.methodName] = feature.implementation;
+    }
+    return map;
+};
+const sandboxProvideFeatures = (sandbox, features) => {
+    const mappedFeatures = mapFeatures(features);
+    for (const packageName of Object.keys(mappedFeatures)) {
+        const methods = mappedFeatures[packageName];
+        sandbox.provide(packageName, methods);
+    }
+};
+exports.sandboxProvideFeatures = sandboxProvideFeatures;

package/sandbox/sandbox.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @author WMXPY
+ * @namespace Sandbox
+ * @description Sandbox
+ */
+import { MarkedResult, Sandbox } from "@sudoo/marked";
+import { SandboxExecuteConfig } from "./definition/config";
+import { SandboxEnvironment } from "./definition/environment";
+import { SandboxFeature } from "./feature/feature";
+export declare const createSandbox: (features: SandboxFeature[]) => Sandbox;
+export declare const executeSandboxScript: (script: string, features: SandboxFeature[], environment: SandboxEnvironment, config: SandboxExecuteConfig) => Promise<MarkedResult>;

package/sandbox/sandbox.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Sandbox
+ * @description Sandbox
+ */
+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.executeSandboxScript = exports.createSandbox = void 0;
+const marked_1 = require("@sudoo/marked");
+const marked_mixin_date_1 = require("@sudoo/marked-mixin-date");
+const marked_mixin_json_1 = require("@sudoo/marked-mixin-json");
+const marked_mixin_math_1 = require("@sudoo/marked-mixin-math");
+const marked_mixin_object_1 = require("@sudoo/marked-mixin-object");
+const marked_mixin_parse_1 = require("@sudoo/marked-mixin-parse");
+const feature_1 = require("./provide/feature");
+const createSandbox = (features) => {
+    const sandbox = marked_1.Sandbox.fromAllEvaluators();
+    sandbox.use(marked_mixin_date_1.markedDateMixinFactory.createInjectMixin("Date"));
+    sandbox.use(marked_mixin_json_1.markedJsonMixinFactory.createInjectMixin("Json"));
+    sandbox.use(marked_mixin_math_1.markedMathMixinFactory.createInjectMixin("Math"));
+    sandbox.use(marked_mixin_object_1.markedObjectMixinFactory.createInjectMixin("Object"));
+    sandbox.use(marked_mixin_parse_1.markedParseMixinFactory.createInjectMixin("Parse"));
+    (0, feature_1.sandboxProvideFeatures)(sandbox, features);
+    return sandbox;
+};
+exports.createSandbox = createSandbox;
+const executeSandboxScript = (script, features, environment, config) => __awaiter(void 0, void 0, void 0, function* () {
+    const sandbox = (0, exports.createSandbox)(features);
+    sandbox.inject("environment", environment);
+    sandbox.inject("config", config);
+    return yield sandbox.evaluate(script);
+});
+exports.executeSandboxScript = executeSandboxScript;

package/search/prefix.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @author WMXPY
+ * @namespace Search
+ * @description Prefix
+ */
+import { IMBRICATE_SEARCH_SNIPPET_TYPE, ImbricateSearchSnippet } from "./snippet";
+export declare const getShortPrefixOfSnippet: (snippet: ImbricateSearchSnippet<IMBRICATE_SEARCH_SNIPPET_TYPE>) => string;

package/search/prefix.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Search
+ * @description Prefix
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getShortPrefixOfSnippet = void 0;
+const snippet_1 = require("./snippet");
+const getShortPrefixOfSnippet = (snippet) => {
+    switch (snippet.type) {
+        case snippet_1.IMBRICATE_SEARCH_SNIPPET_TYPE.PAGE: {
+            switch (snippet.source) {
+                case snippet_1.IMBRICATE_SEARCH_SNIPPET_PAGE_SNIPPET_SOURCE.TITLE: {
+                    return "T";
+                }
+                case snippet_1.IMBRICATE_SEARCH_SNIPPET_PAGE_SNIPPET_SOURCE.CONTENT: {
+                    return "C";
+                }
+            }
+        }
+    }
+    return "?";
+};
+exports.getShortPrefixOfSnippet = getShortPrefixOfSnippet;

package/search/snippet.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @author WMXPY
+ * @namespace Search
+ * @description Snippet
+ */
+export declare enum IMBRICATE_SEARCH_SNIPPET_TYPE {
+    PAGE = "PAGE"
+}
+export declare enum IMBRICATE_SEARCH_SNIPPET_PAGE_SNIPPET_SOURCE {
+    TITLE = "TITLE",
+    CONTENT = "CONTENT"
+}
+type IMBRICATE_SEARCH_SNIPPET_SNIPPET_SOURCE<T extends IMBRICATE_SEARCH_SNIPPET_TYPE> = T extends IMBRICATE_SEARCH_SNIPPET_TYPE.PAGE ? IMBRICATE_SEARCH_SNIPPET_PAGE_SNIPPET_SOURCE : never;
+export type ImbricateSearchSnippet<T extends IMBRICATE_SEARCH_SNIPPET_TYPE> = {
+    readonly type: T;
+    readonly scope: string;
+    readonly identifier: string;
+    readonly headline: string;
+    readonly source: IMBRICATE_SEARCH_SNIPPET_SNIPPET_SOURCE<T>;
+    readonly snippet: string;
+};
+export {};

package/search/snippet.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * @author WMXPY
+ * @namespace Search
+ * @description Snippet
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMBRICATE_SEARCH_SNIPPET_PAGE_SNIPPET_SOURCE = exports.IMBRICATE_SEARCH_SNIPPET_TYPE = void 0;
+var IMBRICATE_SEARCH_SNIPPET_TYPE;
+(function (IMBRICATE_SEARCH_SNIPPET_TYPE) {
+    IMBRICATE_SEARCH_SNIPPET_TYPE["PAGE"] = "PAGE";
+})(IMBRICATE_SEARCH_SNIPPET_TYPE || (exports.IMBRICATE_SEARCH_SNIPPET_TYPE = IMBRICATE_SEARCH_SNIPPET_TYPE = {}));
+var IMBRICATE_SEARCH_SNIPPET_PAGE_SNIPPET_SOURCE;
+(function (IMBRICATE_SEARCH_SNIPPET_PAGE_SNIPPET_SOURCE) {
+    IMBRICATE_SEARCH_SNIPPET_PAGE_SNIPPET_SOURCE["TITLE"] = "TITLE";
+    IMBRICATE_SEARCH_SNIPPET_PAGE_SNIPPET_SOURCE["CONTENT"] = "CONTENT";
+})(IMBRICATE_SEARCH_SNIPPET_PAGE_SNIPPET_SOURCE || (exports.IMBRICATE_SEARCH_SNIPPET_PAGE_SNIPPET_SOURCE = IMBRICATE_SEARCH_SNIPPET_PAGE_SNIPPET_SOURCE = {}));

package/builder/interface.js

@@ -1,54 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Builder
- * @description Interface
- */
-import { verifyInterface } from "../verify/interface";
-var ImbricateInterfaceBuilder = /** @class */ (function () {
-    function ImbricateInterfaceBuilder() {
-        this._interface = {};
-    }
-    ImbricateInterfaceBuilder.fromScratch = function () {
-        return new ImbricateInterfaceBuilder();
-    };
-    ImbricateInterfaceBuilder.prototype.identifier = function (identifier) {
-        this._interface.identifier = identifier;
-        return this;
-    };
-    ImbricateInterfaceBuilder.prototype.version = function (version) {
-        this._interface.version = version;
-        return this;
-    };
-    ImbricateInterfaceBuilder.prototype.protocol = function (protocol) {
-        this._interface.protocol = protocol;
-        return this;
-    };
-    ImbricateInterfaceBuilder.prototype.matcher = function (matcher) {
-        this._interface.matcher = matcher;
-        return this;
-    };
-    ImbricateInterfaceBuilder.prototype.humanFriendlyName = function (humanFriendlyName) {
-        this._interface.humanFriendlyName = humanFriendlyName;
-        return this;
-    };
-    ImbricateInterfaceBuilder.prototype.description = function (description) {
-        this._interface.description = description;
-        return this;
-    };
-    ImbricateInterfaceBuilder.prototype.input = function () {
-        this._interface.input = {};
-        return this;
-    };
-    ImbricateInterfaceBuilder.prototype.output = function () {
-        this._interface.output = {};
-        return this;
-    };
-    ImbricateInterfaceBuilder.prototype.verify = function () {
-        return verifyInterface(this._interface);
-    };
-    ImbricateInterfaceBuilder.prototype.build = function () {
-        return this._interface;
-    };
-    return ImbricateInterfaceBuilder;
-}());
-export { ImbricateInterfaceBuilder };

package/schema/interface.js

@@ -1,6 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Schema
- * @description Interface
- */
-export {};

package/util/writable.js

@@ -1,6 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Util
- * @description Writable
- */
-export {};

package/verify/interface.js

@@ -1,20 +0,0 @@
-/**
- * @author WMXPY
- * @namespace Verify
- * @description Interface
- */
-export var verifyInterface = function (imbricateInterface) {
-    if (typeof imbricateInterface.identifier !== "string") {
-        return false;
-    }
-    if (typeof imbricateInterface.version !== "string") {
-        return false;
-    }
-    if (typeof imbricateInterface.protocol !== "string") {
-        return false;
-    }
-    if (typeof imbricateInterface.matcher !== "string") {
-        return false;
-    }
-    return true;
-};