@metapages/metapage 0.13.9 → 0.13.10-alpha1

package/dist/metapage/Metapage.js

@@ -1,797 +0,0 @@
-import * as objectHash from "object-hash";
-import { VERSION_METAPAGE, METAPAGE_KEY_STATE, METAPAGE_KEY_DEFINITION, } from "./Constants";
-import { JsonRpcMethodsFromChild, } from "./v0_4";
-import { log as MetapageToolsLog, getMatchingVersion, generateMetapageId, existsAnyUrlParam, pageLoaded, isDebugFromUrlsParams, convertMetapageDefinitionToCurrentVersion, } from "./MetapageTools";
-import { INITIAL_NULL_METAPAGE_DEFINITION, MetapageShared } from "./Shared";
-import { MetapageEvents, } from "./v0_4/events";
-import { MetapageIFrameRpcClient } from "./MetapageIFrameRpcClient";
-import { deserializeInputs, serializeInputs } from "./data";
-export var MetapageEventStateType;
-(function (MetapageEventStateType) {
-    MetapageEventStateType["all"] = "all";
-    MetapageEventStateType["delta"] = "delta";
-})(MetapageEventStateType || (MetapageEventStateType = {}));
-const emptyState = () => {
-    return {
-        metaframes: {
-            inputs: {},
-            outputs: {},
-        },
-        plugins: {
-            inputs: {},
-            outputs: {},
-        },
-    };
-};
-export const getLibraryVersionMatching = (version) => {
-    return getMatchingVersion(version);
-};
-export const matchPipe = (outputPipeName, inputPipeName) => {
-    if (!inputPipeName || inputPipeName === "*") {
-        return true;
-    }
-    if (outputPipeName === inputPipeName) {
-        return true;
-    }
-    if (inputPipeName.endsWith("*")) {
-        return outputPipeName.startsWith(inputPipeName.slice(0, -1));
-    }
-    if (inputPipeName.startsWith("*")) {
-        return outputPipeName.endsWith(inputPipeName.slice(1));
-    }
-    return false;
-};
-const CONSOLE_BACKGROUND_COLOR_DEFAULT = "bcbcbc";
-export class Metapage extends MetapageShared {
-    constructor(opts) {
-        super();
-        this._state = emptyState();
-        this._metaframes = {};
-        this._plugins = {};
-        this._pluginOrder = [];
-        this.debug = isDebugFromUrlsParams();
-        this._internalReceivedMessageCounter = 0;
-        this._cachedInputLookupMap = {};
-        this._inputMap = {};
-        this._id = opts && opts.id ? opts.id : generateMetapageId();
-        this._consoleBackgroundColor =
-            opts && opts.color ? opts.color : CONSOLE_BACKGROUND_COLOR_DEFAULT;
-        this.addPipe = this.addPipe.bind(this);
-        this.dispose = this.dispose.bind(this);
-        this.addMetaframe = this.addMetaframe.bind(this);
-        this.addPlugin = this.addPlugin.bind(this);
-        this.getInputsFromOutput = this.getInputsFromOutput.bind(this);
-        this.getMetaframe = this.getMetaframe.bind(this);
-        this.getMetaframeIds = this.getMetaframeIds.bind(this);
-        this.getMetaframeOrPlugin = this.getMetaframeOrPlugin.bind(this);
-        this.getMetaframes = this.getMetaframes.bind(this);
-        this.getPlugin = this.getPlugin.bind(this);
-        this.getPluginIds = this.getPluginIds.bind(this);
-        this.getState = this.getState.bind(this);
-        this.getStateMetaframes = this.getStateMetaframes.bind(this);
-        this.isValidJSONRpcMessage = this.isValidJSONRpcMessage.bind(this);
-        this.log = this.log.bind(this);
-        this.logInternal = this.logInternal.bind(this);
-        this.metaframeIds = this.metaframeIds.bind(this);
-        this.metaframes = this.metaframes.bind(this);
-        this.onMessage = this.onMessage.bind(this);
-        this.pluginIds = this.pluginIds.bind(this);
-        this.plugins = this.plugins.bind(this);
-        this.removeAll = this.removeAll.bind(this);
-        this.removeMetaframe = this.removeMetaframe.bind(this);
-        this.removePlugin = this.removePlugin.bind(this);
-        this.setDebugFromUrlParams = this.setDebugFromUrlParams.bind(this);
-        this.setDefinition = this.setDefinition.bind(this);
-        this.setInput = this.setInput.bind(this);
-        this.setInputs = this.setInputs.bind(this);
-        this.setInputStateOnly = this.setInputStateOnly.bind(this);
-        this.setMetaframeClientInputAndSentClientEvent =
-            this.setMetaframeClientInputAndSentClientEvent.bind(this);
-        this.setOutputStateOnly = this.setOutputStateOnly.bind(this);
-        this.setState = this.setState.bind(this);
-        this.isDisposed = this.isDisposed.bind(this);
-        this.updatePluginsWithDefinition =
-            this.updatePluginsWithDefinition.bind(this);
-        this._emitDefinitionEvent = this._emitDefinitionEvent.bind(this);
-        pageLoaded().then(() => {
-            if (this.isDisposed()) {
-                return;
-            }
-            window.addEventListener("message", this.onMessage);
-            this.log("Initialized");
-        });
-    }
-    static from(metaPageDef, inputs) {
-        if (metaPageDef == null) {
-            throw "Metapage definition cannot be null";
-        }
-        if (typeof metaPageDef === "string") {
-            try {
-                metaPageDef = JSON.parse(metaPageDef);
-            }
-            catch (err) {
-                throw "Cannot parse into JSON:\n${metaPageDef}";
-            }
-        }
-        var metapage = new Metapage();
-        return metapage.setDefinition(metaPageDef);
-    }
-    isDisposed() {
-        return this._metaframes === undefined;
-    }
-    addListenerReturnDisposer(event, listener) {
-        super.addListener(event, listener);
-        const disposer = () => {
-            super.removeListener(event, listener);
-        };
-        return disposer;
-    }
-    setDebugFromUrlParams() {
-        this.debug = existsAnyUrlParam(["MP_DEBUG", "DEBUG", "debug", "mp_debug"]);
-        return this;
-    }
-    getState() {
-        return this._state;
-    }
-    setState(newState) {
-        this._state = newState;
-        this.getMetaframeIds().forEach((metaframeId) => {
-            this.getMetaframe(metaframeId).setInputs(this._state.metaframes.inputs[metaframeId]);
-            this.getMetaframe(metaframeId).setOutputs(this._state.metaframes.outputs[metaframeId]);
-        });
-        this.getPluginIds().forEach((pluginId) => {
-            this.getPlugin(pluginId).setInputs(this._state.plugins.inputs[pluginId]);
-            this.getPlugin(pluginId).setOutputs(this._state.plugins.outputs[pluginId]);
-        });
-        this.emit(MetapageEvents.State, this._state);
-    }
-    getStateMetaframes() {
-        return this._state.metaframes;
-    }
-    getDefinition() {
-        return this._definition;
-    }
-    setDefinition(def, state) {
-        if (!def.version) {
-            throw "Metapage definition must have a version";
-        }
-        const newDefinition = convertMetapageDefinitionToCurrentVersion(def);
-        if (newDefinition.metaframes) {
-            Object.keys(newDefinition.metaframes).forEach((metaframeId) => {
-                if (newDefinition.plugins &&
-                    newDefinition.plugins.includes(metaframeId)) {
-                    this.emitErrorMessage(`Plugin with url=${metaframeId} matches metaframe. Metaframe ids and plugin urls are not allowed to collide`);
-                    throw `Plugin with url=${metaframeId} matches metaframe. Metaframe ids and plugin urls are not allowed to collide`;
-                }
-                var metaframeDefinition = newDefinition.metaframes[metaframeId];
-                if (typeof metaframeDefinition !== "object") {
-                    this.emitErrorMessage(`Metaframe "${metaframeId}" is not an object`);
-                    throw `Metaframe "${metaframeId}" is not an object`;
-                }
-                if (!metaframeDefinition.url) {
-                    this.emitErrorMessage(`Metaframe "${metaframeId}" missing field: url`);
-                    throw `Metaframe "${metaframeId}" missing field: url`;
-                }
-            });
-        }
-        const previousDefinition = this._definition;
-        this._definition = newDefinition;
-        Object.keys(this._metaframes).forEach((metaframeId) => {
-            if (!newDefinition.metaframes || !newDefinition.metaframes[metaframeId]) {
-                this.removeMetaframe(metaframeId);
-            }
-        });
-        Object.keys(this._plugins).forEach((url) => {
-            if (newDefinition.plugins && !newDefinition.plugins.includes(url)) {
-                this.removePlugin(url);
-            }
-        });
-        this._pluginOrder = newDefinition.plugins ? newDefinition.plugins : [];
-        if (state) {
-            this._state = state;
-        }
-        if (newDefinition.metaframes) {
-            Object.keys(newDefinition.metaframes).forEach((newMetaframeId) => {
-                if (!this._metaframes.hasOwnProperty(newMetaframeId)) {
-                    const metaframeDefinition = newDefinition.metaframes[newMetaframeId];
-                    this.addMetaframe(newMetaframeId, metaframeDefinition);
-                }
-            });
-        }
-        if (newDefinition.plugins) {
-            newDefinition.plugins.forEach((url) => {
-                if (!this._plugins.hasOwnProperty(url)) {
-                    this.addPlugin(url);
-                }
-            });
-        }
-        if (previousDefinition !== INITIAL_NULL_METAPAGE_DEFINITION) {
-            window.setTimeout(() => {
-                if (!this.isDisposed() && newDefinition === this._definition) {
-                    this._emitDefinitionEvent();
-                    if (state) {
-                        this.emit(MetapageEvents.State, this._state);
-                    }
-                }
-            }, 0);
-        }
-        return this;
-    }
-    _emitDefinitionEvent() {
-        const event = {
-            definition: this._definition,
-            metaframes: this._metaframes,
-            plugins: this._plugins,
-        };
-        this.emit(MetapageEvents.Definition, event);
-    }
-    addPipe(target, input) {
-        if (!this._inputMap[target]) {
-            this._inputMap[target] = [];
-        }
-        this._inputMap[target].push(input);
-    }
-    removeMetaframe(metaframeId) {
-        if (!this._metaframes[metaframeId]) {
-            return;
-        }
-        this._metaframes[metaframeId].dispose();
-        delete this._metaframes[metaframeId];
-        delete this._state.metaframes.inputs[metaframeId];
-        delete this._state.metaframes.outputs[metaframeId];
-        delete this._inputMap[metaframeId];
-        Object.keys(this._inputMap).forEach((otherMetaframeId) => {
-            const inputPipes = this._inputMap[otherMetaframeId];
-            let index = 0;
-            while (index <= inputPipes.length) {
-                if (inputPipes[index] && inputPipes[index].metaframe === metaframeId) {
-                    inputPipes.splice(index, 1);
-                }
-                else {
-                    index++;
-                }
-            }
-        });
-        this._cachedInputLookupMap = {};
-    }
-    removePlugin(url) {
-        if (!this._plugins[url]) {
-            return;
-        }
-        this._plugins[url].dispose();
-        delete this._plugins[url];
-        delete this._state.plugins.inputs[url];
-        delete this._state.plugins.outputs[url];
-    }
-    removeAll() {
-        Object.keys(this._metaframes).forEach((id) => this._metaframes[id].dispose());
-        Object.keys(this._plugins).forEach((id) => this._plugins[id].dispose());
-        this._metaframes = {};
-        this._plugins = {};
-        this._state = emptyState();
-        this._inputMap = {};
-        this._cachedInputLookupMap = {};
-    }
-    metaframes() {
-        return this.getMetaframes();
-    }
-    metaframeIds() {
-        return this.getMetaframeIds();
-    }
-    getMetaframeIds() {
-        return Object.keys(this._metaframes);
-    }
-    getMetaframes() {
-        return Object.assign({}, this._metaframes);
-    }
-    plugins() {
-        return Object.assign({}, this._plugins);
-    }
-    pluginIds() {
-        return this.getPluginIds();
-    }
-    getPluginIds() {
-        return this._pluginOrder.slice(0);
-    }
-    getMetaframe(id) {
-        return this._metaframes[id];
-    }
-    getPlugin(url) {
-        return this._plugins[url];
-    }
-    addMetaframe(metaframeId, definition) {
-        if (!metaframeId) {
-            throw "addMetaframe missing metaframeId";
-        }
-        if (!definition) {
-            throw "addMetaframe missing definition";
-        }
-        if (this._metaframes[metaframeId]) {
-            this.emitErrorMessage(`Existing metaframe for id=${metaframeId}`);
-            throw `Existing metaframe for id=${metaframeId}`;
-        }
-        if (!definition.url) {
-            this.emitErrorMessage(`Metaframe definition missing url id=${metaframeId}`);
-            throw `Metaframe definition missing url id=${metaframeId}`;
-        }
-        var iframeClient = new MetapageIFrameRpcClient(this, definition.url, metaframeId, this._id, this._consoleBackgroundColor, this.debug).setMetapage(this);
-        this._metaframes[metaframeId] = iframeClient;
-        iframeClient.addListener(MetapageEvents.Error, (err) => {
-            this.emit(MetapageEvents.Error, {
-                metaframeId: iframeClient.id,
-                metaframeUrl: iframeClient.url,
-                error: err,
-            });
-        });
-        if (definition.inputs) {
-            definition.inputs.forEach((input) => this.addPipe(metaframeId, input));
-        }
-        iframeClient.setInputs(this._state.metaframes.inputs[metaframeId]);
-        return iframeClient;
-    }
-    addPlugin(url) {
-        if (!url) {
-            throw "Plugin missing url";
-        }
-        const iframeClient = new MetapageIFrameRpcClient(this, url, url, this._id, this._consoleBackgroundColor, this.debug)
-            .setInputs(this._state.plugins.inputs[url])
-            .setMetapage(this)
-            .setPlugin();
-        bindPlugin(this, iframeClient);
-        this._plugins[url] = iframeClient;
-        return iframeClient;
-    }
-    dispose() {
-        this.log("disposing");
-        super.removeAllListeners();
-        window.removeEventListener("message", this.onMessage);
-        if (this._metaframes) {
-            Object.keys(this._metaframes).forEach((metaframeId) => this._metaframes[metaframeId].dispose());
-        }
-        if (this._plugins) {
-            Object.keys(this._plugins).forEach((pluginId) => this._plugins[pluginId].dispose());
-        }
-        this._id = undefined;
-        this._metaframes = undefined;
-        this._plugins = undefined;
-        this._state = undefined;
-        this._cachedInputLookupMap = undefined;
-        this._inputMap = undefined;
-    }
-    log(o, color, backgroundColor) {
-        if (!this.debug) {
-            return;
-        }
-        this.logInternal(o, color, backgroundColor);
-    }
-    error(err) {
-        this.logInternal(err, "f00", this._consoleBackgroundColor);
-        this.emitErrorMessage(`${err}`);
-    }
-    emitErrorMessage(err) {
-        this.emit(MetapageEvents.Error, err);
-    }
-    getInputsFromOutput(source, outputPipeId) {
-        if (!this._cachedInputLookupMap[source]) {
-            this._cachedInputLookupMap[source] = {};
-        }
-        if (!this._cachedInputLookupMap[source][outputPipeId]) {
-            var targets = [];
-            this._cachedInputLookupMap[source][outputPipeId] = targets;
-            Object.keys(this._inputMap).forEach((metaframeId) => {
-                if (metaframeId === source) {
-                    return;
-                }
-                this._inputMap[metaframeId].forEach((inputPipe) => {
-                    if (inputPipe.metaframe == source) {
-                        if (matchPipe(outputPipeId, inputPipe.source)) {
-                            var targetName = inputPipe.target;
-                            if (!inputPipe.target ||
-                                inputPipe.target.startsWith("*") ||
-                                inputPipe.target === "") {
-                                targetName = outputPipeId;
-                            }
-                            targets.push({ metaframe: metaframeId, pipe: targetName });
-                        }
-                    }
-                });
-            });
-        }
-        return this._cachedInputLookupMap[source][outputPipeId];
-    }
-    isValidJSONRpcMessage(message) {
-        if (message.jsonrpc !== "2.0") {
-            return false;
-        }
-        const method = message.method;
-        switch (method) {
-            case JsonRpcMethodsFromChild.SetupIframeClientRequest:
-                return true;
-            default:
-                var iframeId = message.iframeId;
-                if (iframeId &&
-                    !(message.parentId === this._id &&
-                        (this._metaframes[iframeId] || this._plugins[iframeId]))) {
-                    return false;
-                }
-                return true;
-        }
-    }
-    setInput(iframeId, inputPipeId, value) {
-        this.setInputStateOnly(iframeId, inputPipeId, value);
-        this.setMetaframeClientInputAndSentClientEvent(iframeId, inputPipeId, value);
-        this.emit(MetapageEvents.State, this._state);
-        this.emit(MetapageEvents.Inputs, this._state);
-    }
-    setMetaframeClientInputAndSentClientEvent(iframeId, inputPipeId, value) {
-        if (typeof iframeId === "object") {
-            if (inputPipeId || value) {
-                throw "bad arguments, see API docs";
-            }
-            const inputs = iframeId;
-            Object.keys(inputs).forEach((id) => {
-                var metaframeId = id;
-                var metaframeInputs = inputs[metaframeId];
-                if (typeof metaframeInputs !== "object") {
-                    throw "bad arguments, see API docs";
-                }
-                var iframeClient = this._metaframes[metaframeId];
-                if (iframeClient) {
-                    iframeClient.setInputs(metaframeInputs);
-                }
-                else {
-                    this.error("No iframe id=$metaframeId");
-                }
-            });
-        }
-        else if (typeof iframeId === "string") {
-            const iframeClient = this._metaframes[iframeId];
-            if (iframeClient == null) {
-                this.error(`No iframe id=${iframeId}`);
-            }
-            if (typeof inputPipeId === "string") {
-                iframeClient.setInput(inputPipeId, value);
-            }
-            else if (typeof inputPipeId === "object") {
-                iframeClient.setInputs(inputPipeId);
-            }
-            else {
-                throw "bad arguments, see API docs";
-            }
-        }
-        else {
-            throw "bad arguments, see API docs";
-        }
-    }
-    setInputs(iframeId, inputPipeId, value) {
-        this.setInput(iframeId, inputPipeId, value);
-    }
-    setOutputStateOnly(iframeId, inputPipeId, value) {
-        this._setStateOnly(false, iframeId, inputPipeId, value);
-    }
-    setInputStateOnly(iframeId, inputPipeId, value) {
-        this._setStateOnly(true, iframeId, inputPipeId, value);
-    }
-    _setStateOnly(isInputs, iframeId, inputPipeId, value) {
-        if (typeof iframeId === "object") {
-            if (inputPipeId || value) {
-                throw "If first argument is an object, subsequent args should be undefined";
-            }
-            const inputsMetaframesNew = iframeId;
-            Object.keys(inputsMetaframesNew).forEach((metaframeId) => {
-                var metaframeValuesNew = inputsMetaframesNew[metaframeId];
-                if (typeof metaframeValuesNew !== "object") {
-                    throw "Object values must be objects";
-                }
-                const isMetaframe = this._metaframes.hasOwnProperty(metaframeId);
-                if (!isMetaframe && !this._plugins.hasOwnProperty(metaframeId)) {
-                    throw "No metaframe or plugin: ${metaframeId}";
-                }
-                const inputOrOutputState = isMetaframe
-                    ? isInputs
-                        ? this._state.metaframes.inputs
-                        : this._state.metaframes.outputs
-                    : isInputs
-                        ? this._state.plugins.inputs
-                        : this._state.plugins.outputs;
-                inputOrOutputState[metaframeId] = inputOrOutputState[metaframeId]
-                    ? inputOrOutputState[metaframeId]
-                    : {};
-                Object.keys(metaframeValuesNew).forEach((metaframePipedId) => {
-                    if (metaframeValuesNew[metaframePipedId] === undefined) {
-                        delete inputOrOutputState[metaframeId][metaframePipedId];
-                    }
-                    else {
-                        inputOrOutputState[metaframeId][metaframePipedId] =
-                            metaframeValuesNew[metaframePipedId];
-                    }
-                });
-            });
-        }
-        else if (typeof iframeId === "string") {
-            const metaframeId = iframeId;
-            const isMetaframe = this._metaframes.hasOwnProperty(metaframeId);
-            if (!isMetaframe && !this._plugins.hasOwnProperty(metaframeId)) {
-                throw `No metaframe or plugin: ${metaframeId}`;
-            }
-            const inputOrOutputState = isMetaframe
-                ? isInputs
-                    ? this._state.metaframes.inputs
-                    : this._state.metaframes.outputs
-                : isInputs
-                    ? this._state.plugins.inputs
-                    : this._state.plugins.outputs;
-            if (typeof inputPipeId === "string") {
-                inputOrOutputState[metaframeId] = inputOrOutputState[metaframeId]
-                    ? inputOrOutputState[metaframeId]
-                    : {};
-                const metaframePipeId = inputPipeId;
-                if (value === undefined) {
-                    delete inputOrOutputState[metaframeId][metaframePipeId];
-                }
-                else {
-                    inputOrOutputState[metaframeId][metaframePipeId] = value;
-                }
-            }
-            else if (typeof inputPipeId === "object") {
-                inputOrOutputState[metaframeId] = inputOrOutputState[metaframeId]
-                    ? inputOrOutputState[metaframeId]
-                    : {};
-                const metaframeValuesNew = inputPipeId;
-                Object.keys(metaframeValuesNew).forEach((metaframePipedId) => {
-                    if (metaframeValuesNew[metaframePipedId] === undefined) {
-                        delete inputOrOutputState[metaframeId][metaframePipedId];
-                    }
-                    else {
-                        inputOrOutputState[metaframeId][metaframePipedId] =
-                            metaframeValuesNew[metaframePipedId];
-                    }
-                });
-            }
-            else {
-                throw "Second argument must be a string or an object";
-            }
-        }
-        else {
-            throw "First argument must be a string or an object";
-        }
-    }
-    getMetaframeOrPlugin(key) {
-        var val = this._metaframes[key];
-        if (!val) {
-            val = this._plugins[key];
-        }
-        return val;
-    }
-    onMessage(e) {
-        if (typeof e.data === "object") {
-            const jsonrpc = e.data;
-            if (!this.isValidJSONRpcMessage(jsonrpc)) {
-                return;
-            }
-            var method = jsonrpc.method;
-            const metaframeId = jsonrpc.iframeId;
-            if (!metaframeId) {
-                return;
-            }
-            const metaframeOrPlugin = this.getMetaframeOrPlugin(metaframeId);
-            const isPlugin = this._plugins[metaframeId];
-            jsonrpc["_messageCount"] = ++this
-                ._internalReceivedMessageCounter;
-            if (this.debug) {
-                this.log(`processing ${JSON.stringify(jsonrpc, null, "  ").substr(0, 500)}`);
-            }
-            switch (method) {
-                case JsonRpcMethodsFromChild.SetupIframeClientRequest:
-                    if (metaframeOrPlugin) {
-                        metaframeOrPlugin.register();
-                    }
-                    break;
-                case JsonRpcMethodsFromChild.SetupIframeServerResponseAck:
-                    if (metaframeOrPlugin) {
-                        const params = jsonrpc.params;
-                        metaframeOrPlugin.registered(params.version);
-                    }
-                    break;
-                case JsonRpcMethodsFromChild.OutputsUpdate:
-                    const outputs = jsonrpc.params;
-                    if (this._metaframes[metaframeId]) {
-                        var iframe = this._metaframes[metaframeId];
-                        this.setOutputStateOnly(metaframeId, outputs);
-                        iframe.setOutputs(outputs);
-                        this.emit(MetapageEvents.State, this._state);
-                        var modified = false;
-                        const outputKeys = Object.keys(outputs);
-                        const collectedOutputs = {};
-                        outputKeys.forEach((outputKey, i) => {
-                            const targets = this.getInputsFromOutput(metaframeId, outputKey);
-                            if (targets.length > 0) {
-                                targets.forEach((target) => {
-                                    if (!collectedOutputs[target.metaframe]) {
-                                        collectedOutputs[target.metaframe] = {};
-                                    }
-                                    collectedOutputs[target.metaframe][target.pipe] =
-                                        outputs[outputKey];
-                                    this.setInputStateOnly(target.metaframe, target.pipe, outputs[outputKey]);
-                                    modified = true;
-                                });
-                            }
-                        });
-                        Object.keys(collectedOutputs).forEach((metaframeId) => {
-                            this._metaframes[metaframeId].setInputs(collectedOutputs[metaframeId]);
-                        });
-                        if (modified) {
-                            this.emit(MetapageEvents.State, this._state);
-                        }
-                        if (this.debug) {
-                            iframe.ack({ jsonrpc: jsonrpc, state: this._state });
-                        }
-                    }
-                    else if (this._plugins[metaframeId]) {
-                        const outputPersistanceAllowed = !outputs[METAPAGE_KEY_STATE] && !outputs[METAPAGE_KEY_DEFINITION];
-                        if (outputPersistanceAllowed) {
-                            this.setOutputStateOnly(metaframeId, outputs);
-                        }
-                        this._plugins[metaframeId].setOutputs(outputs);
-                        if (outputPersistanceAllowed) {
-                            this.emit(MetapageEvents.State, this._state);
-                        }
-                        if (this.debug) {
-                            this._plugins[metaframeId].ack({
-                                jsonrpc: jsonrpc,
-                                state: this._state,
-                            });
-                        }
-                    }
-                    else {
-                        this.error(`missing metaframe/plugin=$metaframeId`);
-                    }
-                    break;
-                case JsonRpcMethodsFromChild.InputsUpdate:
-                    var inputs = jsonrpc.params;
-                    if (this.debug)
-                        this.log(`inputs ${JSON.stringify(inputs)} from ${metaframeId}`);
-                    if (this._metaframes[metaframeId]) {
-                        this.setInputStateOnly(metaframeId, inputs);
-                        this._metaframes[metaframeId].setInputs(inputs);
-                        this.emit(MetapageEvents.State, this._state);
-                        if (this.debug) {
-                            this._metaframes[metaframeId].ack({
-                                jsonrpc: jsonrpc,
-                                state: this._state,
-                            });
-                        }
-                    }
-                    else if (this._plugins[metaframeId]) {
-                        const inputPersistanceAllowed = !inputs[METAPAGE_KEY_STATE] && !inputs[METAPAGE_KEY_DEFINITION];
-                        if (inputPersistanceAllowed) {
-                            this.setInputStateOnly(metaframeId, inputs);
-                        }
-                        this._plugins[metaframeId].setInputs(inputs);
-                        if (inputPersistanceAllowed) {
-                            this.emit(MetapageEvents.State, this._state);
-                        }
-                        if (this.debug) {
-                            this._plugins[metaframeId].ack({
-                                jsonrpc: jsonrpc,
-                                state: this._state,
-                            });
-                        }
-                    }
-                    else {
-                        console.error(`InputsUpdate failed no metaframe or plugin id: "${metaframeId}"`);
-                        this.error(`InputsUpdate failed no metaframe or plugin id: "${metaframeId}"`);
-                    }
-                    break;
-                case JsonRpcMethodsFromChild.PluginRequest:
-                    if (isPlugin && metaframeOrPlugin) {
-                        if (metaframeOrPlugin.hasPermissionsState()) {
-                            metaframeOrPlugin.setInput(METAPAGE_KEY_STATE, this._state);
-                            if (this.debug) {
-                                metaframeOrPlugin.ack({ jsonrpc: jsonrpc, state: this._state });
-                            }
-                        }
-                    }
-                    break;
-                case JsonRpcMethodsFromChild.HashParamsUpdate:
-                    if (!isPlugin && metaframeOrPlugin) {
-                        const hashParamsUpdatePayload = jsonrpc.params;
-                        const url = new URL(metaframeOrPlugin.url);
-                        url.hash = hashParamsUpdatePayload.hash;
-                        metaframeOrPlugin.url = url.href;
-                        this._definition.metaframes[hashParamsUpdatePayload.metaframe].url =
-                            url.href;
-                        this._emitDefinitionEvent();
-                    }
-                    break;
-                default:
-                    if (this.debug) {
-                        this.log(`Unknown RPC method: "${method}"`);
-                    }
-            }
-            this.emit(MetapageEvents.Message, jsonrpc);
-        }
-    }
-    updatePluginsWithDefinition() {
-        const currentMetapageDef = this.getDefinition();
-        Object.values(this._plugins).forEach((plugin) => {
-            if (plugin.hasPermissionsDefinition()) {
-                updatePluginWithDefinition(plugin);
-            }
-        });
-    }
-    logInternal(o, color, backgroundColor) {
-        backgroundColor = backgroundColor
-            ? backgroundColor
-            : this._consoleBackgroundColor;
-        let s;
-        if (typeof o === "string") {
-            s = o;
-        }
-        else if (typeof o === "number") {
-            s = o + "";
-        }
-        else {
-            s = JSON.stringify(o);
-        }
-        s = this._id ? `Metapage[${this._id}] ${s}` : s;
-        MetapageToolsLog(s, color, backgroundColor);
-    }
-}
-Metapage.version = VERSION_METAPAGE;
-Metapage.DEFINITION = MetapageEvents.Definition;
-Metapage.DEFINITION_UPDATE_REQUEST = MetapageEvents.DefinitionUpdateRequest;
-Metapage.ERROR = MetapageEvents.Error;
-Metapage.INPUTS = MetapageEvents.Inputs;
-Metapage.MESSAGE = MetapageEvents.Message;
-Metapage.OUTPUTS = MetapageEvents.Outputs;
-Metapage.STATE = MetapageEvents.State;
-Metapage.deserializeInputs = deserializeInputs;
-Metapage.serializeInputs = serializeInputs;
-const bindPlugin = async (metapage, plugin) => {
-    try {
-        const metaframeDef = await plugin.getDefinition();
-        if (!metaframeDef) {
-            throw `${plugin.url}`;
-        }
-        if (plugin.isDisposed()) {
-            return;
-        }
-        if (plugin.hasPermissionsDefinition()) {
-            var disposer = metapage.addListenerReturnDisposer(MetapageEvents.Definition, (definition) => {
-                plugin.setInput(METAPAGE_KEY_DEFINITION, definition.definition);
-            });
-            plugin._disposables.push(disposer);
-            var currentMetapageDef = metapage.getDefinition();
-            if (currentMetapageDef) {
-                plugin.setInput(METAPAGE_KEY_DEFINITION, currentMetapageDef);
-                if (metaframeDef.outputs) {
-                    var disposer = plugin.onOutput(METAPAGE_KEY_DEFINITION, (definition) => {
-                        if (objectHash.sha1(definition) !==
-                            objectHash.sha1(currentMetapageDef)) {
-                            metapage.emit(MetapageEvents.DefinitionUpdateRequest, definition);
-                        }
-                    });
-                    plugin._disposables.push(disposer);
-                }
-            }
-        }
-        if (plugin.hasPermissionsState()) {
-            if (metaframeDef.outputs) {
-                var disposer = plugin.onOutput(METAPAGE_KEY_STATE, (state) => {
-                    metapage.setState(state);
-                });
-                plugin._disposables.push(disposer);
-            }
-        }
-    }
-    catch (err) {
-        console.error(err);
-        metapage.emit(MetapageEvents.Error, `Failed to get plugin definition from "${plugin.getDefinitionUrl()}", error=${err}`);
-    }
-};
-const updatePluginWithDefinition = (plugin) => {
-    const currentMetapageDef = plugin._metapage.getDefinition();
-    plugin.setInput(METAPAGE_KEY_DEFINITION, currentMetapageDef);
-};
-//# sourceMappingURL=Metapage.js.map