@prismatic-io/prism 3.3.0 → 4.2.0

package/lib/commands/components/dev/run.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const graphql_1 = require("../../../graphql");
+const child_process_1 = require("child_process");
+const spawnProcess = ([command, ...args], env) => {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, args, {
+            env: { ...process.env, ...env },
+        });
+        child.stdout.pipe(process.stdout);
+        child.stderr.pipe(process.stderr);
+        child.on("close", (code) => (code === 0 ? resolve() : reject()));
+    });
+};
+class RunCommand extends core_1.Command {
+    async run() {
+        const { argv, flags: { integrationId, connectionKey }, } = await this.parse(RunCommand);
+        const result = await (0, graphql_1.gqlRequest)({
+            document: (0, graphql_1.gql) `
+        query integration($id: ID!) {
+          integration(id: $id) {
+            testConfigVariables {
+              nodes {
+                requiredConfigVariable {
+                  key
+                }
+                inputs {
+                  nodes {
+                    name
+                    value
+                  }
+                }
+                meta
+              }
+            }
+          }
+        }
+      `,
+            variables: {
+                id: integrationId,
+            },
+        });
+        const nodes = result.integration.testConfigVariables.nodes;
+        const [connection] = nodes.filter(({ requiredConfigVariable: { key } }) => key === connectionKey);
+        if (!connection) {
+            core_1.CliUx.ux.error("Failed to find active connection.", { exit: 1 });
+        }
+        const { meta, inputs } = connection;
+        const fields = inputs.nodes.reduce((result, { name, value }) => ({ ...result, [name]: value }), {});
+        const value = JSON.stringify({
+            ...JSON.parse(meta),
+            fields,
+        });
+        await spawnProcess(argv, { PRISMATIC_CONNECTION_VALUE: value });
+    }
+}
+exports.default = RunCommand;
+RunCommand.description = `Fetch an integration's active connection and execute a CLI command with that connection's fields as an environment variable.`;
+RunCommand.usage = "prism components:dev:run -i <value> -c <value> -- /command/to/run";
+RunCommand.examples = [
+    {
+        description: `To simply print an integration's basic auth config variable named "My Credentials" and pipe the resulting JSON to jq, run:`,
+        command: `$ prism components:dev:run
+    --integrationId SW50ZWdyYXRpb246Y2YyMjJlMWUtMzJiYy00NTNhLWIzOWQtYTliNzUwMDAyNjBk
+    --connectionKey "My Credentials" --
+    printenv \${PRISMATIC_CONNECTION_VALUE} | jq`,
+    },
+    {
+        description: `If one of your integrations has an authenticated OAuth 2.0 config variable "Slack Connection", you could run your component's unit tests with that environment variable:`,
+        command: `$ prism components:dev:run -i SW50ZWexample -c "Slack Connection" -- yarn run test`,
+    },
+];
+// Allow us to manually capture argv so we can isolate the wrapped command.
+RunCommand.strict = false;
+// TODO: Make this derive from the component manifest using the same
+// logic as the `test` command.
+RunCommand.flags = {
+    integrationId: core_1.Flags.string({
+        required: true,
+        char: "i",
+        description: "Integration ID",
+    }),
+    connectionKey: core_1.Flags.string({
+        required: true,
+        char: "c",
+        description: "Key of the connection config variable to fetch meta/state for",
+    }),
+};

package/lib/commands/components/dev/test.js

@@ -0,0 +1,218 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("util");
+const dotenv_1 = __importDefault(require("dotenv"));
+const core_1 = require("@oclif/core");
+const inquirer_1 = __importDefault(require("inquirer"));
+const lodash_1 = require("lodash");
+const publish_1 = require("../../../utils/component/publish");
+const logs_1 = require("../../../utils/execution/logs");
+const definition_1 = require("../../../utils/integration/definition");
+const import_1 = require("../../../utils/integration/import");
+const invoke_1 = require("../../../utils/integration/invoke");
+const query_1 = require("../../../utils/integration/query");
+const fs_1 = require("../../../fs");
+const query_2 = require("../../../utils/user/query");
+const setTimeoutPromise = (0, util_1.promisify)(setTimeout);
+const envVarCase = (name) => (0, lodash_1.upperCase)((0, lodash_1.snakeCase)(name)).replace(/\s+/g, "_");
+const toInquirerInputType = (type, collection) => {
+    if (collection) {
+        // FIXME: Improve prompting instead of instantly bailing to editor.
+        return "editor";
+    }
+    switch (type) {
+        case "boolean":
+            return "checkbox";
+        case "password":
+            return "password";
+        case "code":
+            return "editor";
+        default:
+            return "input";
+    }
+};
+const getInputQuestion = ({ key, label, type, collection, default: defaultValue, }) => ({
+    type: toInquirerInputType(type, collection),
+    name: key,
+    message: `${label}:`,
+    when: (answers) => {
+        var _a;
+        const envVar = envVarCase(key);
+        const exists = envVar in process.env;
+        if (exists) {
+            const value = (_a = process.env[envVar]) !== null && _a !== void 0 ? _a : "";
+            answers[key] = collection
+                ? { type: "complex", value: JSON.parse(value) }
+                : { type: "value", value };
+        }
+        return !exists;
+    },
+    filter: (value) => {
+        if (type === "connection") {
+            return { type: "configVar", value };
+        }
+        if (collection) {
+            return {
+                type: "complex",
+                value: JSON.parse(value),
+            };
+        }
+        return {
+            type: "value",
+            value,
+        };
+    },
+    default: () => (type === "connection" ? "testConnection" : defaultValue),
+});
+const valuesFromAnswers = ({ action, actionInputs, connection, connectionInputs = {}, }) => {
+    const actionValues = Object.entries(actionInputs).reduce((result, [key, value]) => ({
+        ...result,
+        [key]: value,
+    }), {});
+    const connectionValues = Object.entries(connectionInputs).reduce((result, [key, value]) => ({
+        ...result,
+        [key]: value,
+    }), {});
+    const connectionInfo = connection
+        ? { key: connection.key, values: connectionValues }
+        : undefined;
+    return {
+        actionInfo: { key: action.key, values: actionValues },
+        connectionInfo,
+    };
+};
+class TestCommand extends core_1.Command {
+    async run() {
+        const { flags: { envPath }, } = await this.parse(TestCommand);
+        if (await (0, fs_1.exists)(envPath)) {
+            const { error } = dotenv_1.default.config({ path: envPath });
+            if (error) {
+                core_1.CliUx.ux.error(`Failed to load specified dotenv file: ${error}`, {
+                    exit: 1,
+                });
+            }
+        }
+        core_1.CliUx.ux.action.start("Validating Component");
+        const { name } = await (0, query_2.whoAmI)();
+        if (!name) {
+            core_1.CliUx.ux.error("Failed to determine the name of the currently logged in user.", {
+                exit: 1,
+            });
+        }
+        const testingKey = (0, lodash_1.kebabCase)(name);
+        const definition = await (0, publish_1.loadEntrypoint)();
+        const { key: componentKey, public: isPublic } = definition;
+        definition.key = `${componentKey}-${testingKey}-testing`;
+        definition.display.label = `${definition.display.label} ${name} Testing`;
+        await (0, publish_1.validateDefinition)(definition);
+        const packagePath = await (0, publish_1.createComponentPackage)();
+        const signatureMatches = await (0, publish_1.checkSignature)(definition, packagePath);
+        core_1.CliUx.ux.action.stop();
+        if (!signatureMatches) {
+            core_1.CliUx.ux.action.start("Publishing Component");
+            const { iconUploadUrl, packageUploadUrl, connectionIconUploadUrls } = await (0, publish_1.publishDefinition)(definition);
+            const { display: { iconPath }, } = definition;
+            await (0, publish_1.uploadFile)(iconPath, iconUploadUrl);
+            await (0, publish_1.uploadConnectionIcons)(definition, connectionIconUploadUrls);
+            await (0, publish_1.uploadFile)(packagePath, packageUploadUrl);
+            core_1.CliUx.ux.action.stop();
+        }
+        const publishedTimestamp = Date.now();
+        const actions = definition.actions || {};
+        const { action } = await inquirer_1.default.prompt({
+            type: "list",
+            name: "action",
+            message: "Action:",
+            choices: Object.entries(actions).map(([key, { display: { label }, },]) => ({
+                name: label,
+                value: key,
+                short: key,
+            })),
+            default: Object.keys(actions)[0],
+            filter: (value) => actions[value],
+        });
+        const { inputs } = action;
+        // Ask for values of action's inputs
+        const actionInputs = await inquirer_1.default.prompt(inputs.map((i) => getInputQuestion(i)));
+        const answers = {
+            action,
+            actionInputs,
+        };
+        // Ask about Connection to test if there is a connection type input
+        const hasConnection = inputs.some(({ type }) => type === "connection");
+        if (hasConnection) {
+            const connections = definition.connections || [];
+            const { connection } = await inquirer_1.default.prompt({
+                type: "list",
+                name: "connection",
+                message: "Connection:",
+                choices: connections.map(({ key, label }) => ({
+                    name: label,
+                    value: key,
+                    short: key,
+                })),
+                default: Object.keys(connections)[0],
+                filter: (value) => {
+                    const [connection] = connections.filter(({ key }) => value === key);
+                    return connection;
+                },
+            });
+            // Prompt for connection's inputs
+            const { inputs } = connection;
+            const connectionInputs = await inquirer_1.default.prompt(inputs
+                .filter(({ shown }) => shown === undefined || shown === true)
+                .map((i) => getInputQuestion(i)));
+            Object.assign(answers, { connection, connectionInputs });
+        }
+        const { actionInfo, connectionInfo } = valuesFromAnswers(answers);
+        core_1.CliUx.ux.action.start("Assembling test integration");
+        // FIXME: Wait for version to be available but due to issues we have to do a static wait.
+        const wait = 5000 - (Date.now() - publishedTimestamp);
+        if (wait > 0) {
+            await setTimeoutPromise(wait);
+        }
+        // Build up YAML
+        const harnessYaml = await (0, definition_1.buildComponentTestHarnessIntegration)({
+            integrationInfo: {
+                name: (0, definition_1.componentTestIntegrationName)(componentKey, name),
+            },
+            componentInfo: { key: definition.key, isPublic: isPublic !== null && isPublic !== void 0 ? isPublic : false },
+            actionInfo,
+            connectionInfo,
+        });
+        core_1.CliUx.ux.action.stop();
+        core_1.CliUx.ux.action.start("Updating test Integration");
+        const { integrationId, flows: [{ id: flowId }], pendingAuthorizations, } = await (0, import_1.importDefinition)(harnessYaml);
+        core_1.CliUx.ux.action.stop();
+        // Prompt for user authorization of pending connections
+        if (pendingAuthorizations.length > 0) {
+            const [{ id, url }] = pendingAuthorizations;
+            if (!url) {
+                throw new Error("Did not receive a valid URL for authorization. Verify your Connection inputs.");
+            }
+            core_1.CliUx.ux.url("Authorize URL", url);
+            await core_1.CliUx.ux.anykey("Press any key to open your browser and authorize the Connection");
+            await core_1.CliUx.ux.open(url);
+            core_1.CliUx.ux.action.start("Waiting for Connection authorization");
+            await (0, query_1.pollForActiveConfigVarState)(integrationId, id);
+            core_1.CliUx.ux.action.stop();
+        }
+        core_1.CliUx.ux.action.start("Running test Integration");
+        const { executionId } = await (0, invoke_1.runIntegrationFlow)({ integrationId, flowId });
+        await (0, logs_1.displayLogs)(executionId);
+        core_1.CliUx.ux.action.stop();
+    }
+}
+exports.default = TestCommand;
+TestCommand.description = "Run a Component in Prismatic by publishing it into a test Integration";
+TestCommand.flags = {
+    envPath: core_1.Flags.string({
+        required: false,
+        default: ".env",
+        char: "e",
+        description: "Path to dotenv file to load for supplying testing values",
+    }),
+};

package/lib/commands/components/init/action.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const yeoman_1 = require("../../../yeoman");
+class GenerateActionCommand extends core_1.Command {
+    async run() {
+        await this.parse(GenerateActionCommand);
+        await (0, yeoman_1.runGenerator)("action");
+    }
+}
+exports.default = GenerateActionCommand;
+GenerateActionCommand.description = "Initialize a new Action file";

package/lib/commands/components/init/component.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const yeoman_1 = require("../../../yeoman");
+class GenerateComponentCommand extends core_1.Command {
+    async run() {
+        await this.parse(GenerateComponentCommand);
+        await (0, yeoman_1.runGenerator)("component");
+    }
+}
+exports.default = GenerateComponentCommand;
+GenerateComponentCommand.description = "Initialize a new Component";

package/lib/commands/components/init/connection.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const yeoman_1 = require("../../../yeoman");
+class GenerateConnectionCommand extends core_1.Command {
+    async run() {
+        await this.parse(GenerateConnectionCommand);
+        await (0, yeoman_1.runGenerator)("connection");
+    }
+}
+exports.default = GenerateConnectionCommand;
+GenerateConnectionCommand.description = "Initialize a new Connection file";

package/lib/commands/components/init/index.js

@@ -0,0 +1,142 @@
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const wsdl_tsclient_1 = require("wsdl-tsclient");
+const logger_1 = require("wsdl-tsclient/dist/src/utils/logger");
+const index_1 = require("../../../generate/index");
+const prettier_1 = __importDefault(require("prettier"));
+const glob_promise_1 = __importDefault(require("glob-promise"));
+const yeoman_1 = require("../../../yeoman");
+const componentNameRegex = /^[a-zA-Z0-9][a-zA-Z0-9-_]*[a-zA-Z0-9]$/;
+const getFilesToFormat = async (basename) => {
+    return await (0, glob_promise_1.default)("**/*.ts", {
+        ignore: ["**/node_modules/**"],
+        cwd: path.dirname(basename),
+    });
+};
+const formatSourceFiles = async (basePath, files) => {
+    //format the text of each file
+    await Promise.all(files.map(async (filePath) => {
+        const formattedFile = prettier_1.default.format(await fs_1.promises.readFile(path.resolve(path.dirname(basePath), filePath), "utf-8"), { parser: "typescript" });
+        //write the formatted text to the proper file location
+        await fs_1.promises.writeFile(path.resolve(path.dirname(basePath), filePath), formattedFile);
+    }));
+};
+class InitializeComponent extends core_1.Command {
+    async run() {
+        const { args: { name }, flags: { verbose, "wsdl-path": wsdlPath, "open-api-path": openApiPath }, } = await this.parse(InitializeComponent);
+        if (!componentNameRegex.test(name)) {
+            this.error(`'${name}' contains invalid characters. Please select a component name that starts and ends with alphanumeric characters, and contains only alphanumeric characters, hyphens, and underscores. See https://regex101.com/?regex=${encodeURIComponent(componentNameRegex.source)}`, { exit: 1 });
+        }
+        if (wsdlPath && !(wsdlPath === null || wsdlPath === void 0 ? void 0 : wsdlPath.includes(".wsdl"))) {
+            this.error("If a WSDL is provided it must have an extension of '.wsdl'", {
+                exit: 1,
+            });
+        }
+        this.log(`Creating component directory for "${name}"...`);
+        await fs_1.promises.mkdir(name);
+        const cwd = process.cwd();
+        process.chdir(name);
+        if (openApiPath) {
+            await (0, yeoman_1.runGenerator)("formats", {
+                name,
+                openapi: openApiPath,
+            });
+        }
+        else {
+            // Legacy code paths (mostly; keep the component generator call)
+            await (0, yeoman_1.runGenerator)("component", process.env.NODE_ENV === "test"
+                ? {
+                    name,
+                    description: "Prism-generated Component",
+                    connectionType: "basic",
+                    skipInstall: true,
+                }
+                : { name, skipInstall: Boolean(wsdlPath) });
+            // Need to pop back as the WSDL generator assumes it's a directory up
+            process.chdir(cwd);
+            if (wsdlPath) {
+                if (!verbose) {
+                    // wsdl-tsclient emits pretty noisy logs that aren't particularly useful
+                    logger_1.Logger.disabled();
+                }
+                const wsdlName = path.basename(wsdlPath).split(".wsdl")[0];
+                await (0, wsdl_tsclient_1.parseAndGenerate)(wsdlPath, name, {
+                    caseInsensitiveNames: true,
+                });
+                await (0, index_1.generate)({
+                    projectRoot: name,
+                    projectTemplateName: wsdlName,
+                    projectTemplatePath: wsdlPath,
+                });
+                await (0, index_1.updatePackageJson)({
+                    path: path.resolve(name, "package.json"),
+                    dependencies: { soap: "0.40.0" },
+                });
+                const filesToFormat = await getFilesToFormat(name);
+                await formatSourceFiles(name, filesToFormat);
+            }
+            this.log(`
+"${name}" is ready for development.
+To install dependencies, run either "npm install" or "yarn install"
+To test the component, run "npm run test" or "yarn test"
+To build the component, run "npm run build" or "yarn build"
+To publish the component, run "prism components:publish"
+
+For documentation on writing custom components, visit https://prismatic.io/docs/custom-components/writing-custom-components/
+    `);
+        }
+    }
+}
+exports.default = InitializeComponent;
+InitializeComponent.description = "Initialize a new Component";
+InitializeComponent.flags = {
+    "wsdl-path": core_1.Flags.string({
+        required: false,
+        description: "Path to the WSDL definition file used to generate a Component",
+    }),
+    "open-api-path": core_1.Flags.string({
+        required: false,
+        description: "The path to an OpenAPI Specification file (JSON or YAML) used to generate a Component",
+    }),
+    verbose: core_1.Flags.boolean({
+        required: false,
+        default: false,
+        description: "Output more verbose logging from Component generation",
+    }),
+};
+InitializeComponent.args = [
+    {
+        name: "name",
+        required: true,
+        description: "Name of the new component to create (alphanumeric characters, hyphens, and underscores)",
+    },
+];

package/lib/commands/components/init/trigger.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const yeoman_1 = require("../../../yeoman");
+class GenerateTriggerCommand extends core_1.Command {
+    async run() {
+        await this.parse(GenerateTriggerCommand);
+        await (0, yeoman_1.runGenerator)("trigger");
+    }
+}
+exports.default = GenerateTriggerCommand;
+GenerateTriggerCommand.description = "Initialize a new Trigger file";

package/lib/commands/components/list.js

@@ -1,43 +1,13 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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 });
-const command_1 = __importStar(require("@oclif/command"));
-const graphql_1 = __importStar(require("../../graphql"));
-const cli_ux_1 = require("cli-ux");
-class ListCommand extends command_1.default {
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { flags } = this.parse(ListCommand);
-            const { showAllVersions } = flags;
-            const result = yield graphql_1.default.query({
-                query: graphql_1.gql `
+const core_1 = require("@oclif/core");
+const graphql_1 = require("../../graphql");
+class ListCommand extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(ListCommand);
+        const { showAllVersions } = flags;
+        const result = await (0, graphql_1.gqlRequest)({
+            document: (0, graphql_1.gql) `
         query listComponents($showAllVersions: Boolean) {
           components(allVersions: $showAllVersions) {
             nodes {
@@ -52,33 +22,34 @@ class ListCommand extends command_1.default {
           }
         }
       `,
-                variables: {
-                    showAllVersions,
-                },
-            });
-            cli_ux_1.cli.table(result.data.components.nodes, {
-                id: {
-                    minWidth: 8,
-                    extended: true,
-                },
-                key: {
-                    minWidth: 10,
-                    extended: true,
-                },
-                label: {},
-                public: {},
-                description: {},
-                versionNumber: { header: "Version" },
-                category: {},
-            }, Object.assign({}, flags));
+            variables: {
+                showAllVersions,
+            },
         });
+        core_1.CliUx.ux.table(result.components.nodes, {
+            id: {
+                minWidth: 8,
+                extended: true,
+            },
+            key: {
+                minWidth: 10,
+                extended: true,
+            },
+            label: {},
+            public: {},
+            description: {},
+            versionNumber: { header: "Version" },
+            category: {},
+        }, { ...flags });
     }
 }
 exports.default = ListCommand;
 ListCommand.description = "List available Components";
-ListCommand.flags = Object.assign(Object.assign({}, cli_ux_1.cli.table.flags()), { showAllVersions: command_1.flags.boolean({
+ListCommand.flags = {
+    ...core_1.CliUx.ux.table.flags(),
+    showAllVersions: core_1.Flags.boolean({
         char: "a",
         required: false,
         description: "If specified this command returns all versions of all components rather than only the latest version",
-    }) });
-//# sourceMappingURL=list.js.map
+    }),
+};