@stencila/jesta/dist/dispatch.js

Stencila plugin for executable documents using JavaScript

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.dispatch = void 0;
const ajv_1 = __importDefault(require("ajv"));
const ajv_formats_1 = __importDefault(require("ajv-formats"));
const types_1 = require("./types");
const errors_1 = require("./util/errors");
const validators = ajv_formats_1.default(new ajv_1.default({ strict: false }));
function dispatch(method, params) {
    var _a;
    // Check this is a known method
    if (types_1.Method[method] === undefined)
        throw new errors_1.MethodNotFoundError(method);
    // Get the validation function for the method
    let validator = validators.getSchema(method);
    if (validator === undefined) {
        // @ts-expect-error because indexing `Jesta`
        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
        const { schema } = this[method];
        if (schema !== undefined) {
            validator = validators.addSchema(schema, method).getSchema(method);
        }
    }
    // Validate the supplied parameter against the method's schema (if any)
    if (validator) {
        if (validator(params) !== true) {
            const errors = (_a = validator.errors) !== null && _a !== void 0 ? _a : [];
            let messages = [];
            for (const error of errors) {
                // Convert error message into something that is more easily digestible
                // by humans
                const { instancePath, message, params } = error;
                if (instancePath !== '' && message !== undefined) {
                    messages = [
                        ...messages,
                        `Parameter '${instancePath.slice(1)}' is invalid: ${message}.`,
                    ];
                }
                else if (params.missingProperty !== undefined) {
                    messages = [
                        ...messages,
                        `Parameter '${params.missingProperty}' is required.`,
                    ];
                }
                else {
                    messages = [...messages, `Parameters are invalid`];
                }
            }
            throw new errors_1.InvalidParamError(messages.join(' '), errors);
        }
    }
    // Dispatch to the method
    switch (method) {
        // case Method.build:
        //  return this.build(params.node as Node, params.force as boolean)
        case types_1.Method.call:
            return this.call(params.name, params.args);
        case types_1.Method.clean:
            return this.clean(params.node);
        case types_1.Method.compile:
            return this.compile(params.node, params.force);
        case types_1.Method.convert:
            return this.convert(params.input, params.output, params.from, params.to, params.cache, params.upcast, params.downcast, params.validate);
        case types_1.Method.decode:
            return this.decode(params.content, params.format);
        case types_1.Method.delete:
            return this.delete(params.name);
        case types_1.Method.downcast:
            return this.downcast(params.node);
        case types_1.Method.encode:
            return this.encode(params.node, params.format);
        case types_1.Method.enrich:
            return this.enrich(params.node, params.force);
        case types_1.Method.execute:
            return this.execute(params.node, params.force);
        case types_1.Method.export:
            return this.export(params.node, params.output, params.format, params.downcast, params.validate);
        case types_1.Method.funcs:
            return this.funcs();
        case types_1.Method.get:
            return this.get(params.name);
        case types_1.Method.import:
            return this.import(params.input, params.format, params.cache, params.upcast, params.validate);
        case types_1.Method.pipe:
            return this.pipe(params.node, params.calls);
        case types_1.Method.pull:
            return this.pull(params.input, params.output);
        case types_1.Method.read:
            return this.read(params.input, params.cache);
        case types_1.Method.select:
            return this.select(params.node, params.query, params.lang);
        case types_1.Method.set:
            return this.set(params.name, params.value);
        case types_1.Method.upcast:
            return this.upcast(params.node);
        case types_1.Method.validate:
            return this.validate(params.node, params.force);
        case types_1.Method.vars:
            return this.vars();
        case types_1.Method.write:
            return this.write(params.content, params.output);
    }
    return Promise.resolve(undefined);
}
exports.dispatch = dispatch;