@slicemachine/init 1.0.2-slicecanvas.0 → 1.1.1-alpha.2

package/build/index.js

@@ -1,32 +1,570 @@
 #!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@slicemachine/core");
-const steps_1 = require("./steps");
-const utils_1 = require("./utils");
-async function init() {
-    const cwd = (0, utils_1.findArgument)(process.argv, "cwd") || process.cwd();
-    const base = (0, utils_1.findArgument)(process.argv, "base") || core_1.Utils.CONSTS.DEFAULT_BASE;
-    console.log(core_1.Utils.purple("You're about to configure Slicemachine... Press ctrl + C to cancel"));
-    (0, steps_1.validatePkg)(cwd);
-    await (0, steps_1.loginOrBypass)(base);
-    const config = core_1.FileSystem.PrismicSharedConfigManager.get();
-    const frameworkResult = await (0, steps_1.detectFramework)(cwd);
-    const { existing, name } = await (0, steps_1.maybeExistingRepo)(config.cookies, cwd, config.base);
-    if (!existing) {
-        await (0, steps_1.createRepository)(name, frameworkResult.value, config);
-    }
-    await (0, steps_1.installRequiredDependencies)(cwd, frameworkResult.value);
-    (0, steps_1.configureProject)(cwd, base, name, frameworkResult);
-    (0, steps_1.displayFinalMessage)(cwd);
+
+'use strict';
+
+const core = require('@slicemachine/core');
+const ServerAnalytics = require('analytics-node');
+const path = require('path');
+const util = require('util');
+const child_process = require('child_process');
+const inquirer = require('inquirer');
+const Separator = require('inquirer/lib/objects/separator');
+const cookie = require('@slicemachine/core/build/src/utils/cookie');
+const axios = require('axios');
+const t = require('io-ts');
+const _function = require('fp-ts/function');
+const Either = require('fp-ts/Either');
+const tmp = require('tmp');
+const AdmZip = require('adm-zip');
+const fsExtra = require('fs-extra');
+const fs = require('fs');
+const PackageJson = require('@slicemachine/core/build/src/utils/PackageJson');
+const Manifest = require('@slicemachine/core/build/src/models/Manifest');
+const Files = require('@slicemachine/core/build/src/utils/files');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  const n = Object.create(null);
+  if (e) {
+    for (const k in e) {
+      if (k !== 'default') {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    }
+  }
+  n["default"] = e;
+  return Object.freeze(n);
 }
-try {
-    void init();
+
+const ServerAnalytics__default = /*#__PURE__*/_interopDefaultLegacy(ServerAnalytics);
+const path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+const util__default = /*#__PURE__*/_interopDefaultLegacy(util);
+const inquirer__namespace = /*#__PURE__*/_interopNamespace(inquirer);
+const Separator__default = /*#__PURE__*/_interopDefaultLegacy(Separator);
+const axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+const t__namespace = /*#__PURE__*/_interopNamespace(t);
+const tmp__default = /*#__PURE__*/_interopDefaultLegacy(tmp);
+const AdmZip__default = /*#__PURE__*/_interopDefaultLegacy(AdmZip);
+const fsExtra__default = /*#__PURE__*/_interopDefaultLegacy(fsExtra);
+const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+const Files__default = /*#__PURE__*/_interopDefaultLegacy(Files);
+
+class Tracker {
+  constructor(analytics, repo, identifier, tracking = true) {
+    this.analytics = analytics;
+    this.repo = repo;
+    this.identifier = identifier;
+    this.tracking = tracking;
+    this.Track = {
+      downloadLibrary: (library) => {
+        this.trackEvent("SliceMachine Download Library" /* DownloadLibrary */, { library });
+      }
+    };
+  }
+  static build(writeKey, repo, identifier, tracking = true) {
+    try {
+      if (!repo)
+        return;
+      const analytics = new ServerAnalytics__default["default"](writeKey);
+      return new Tracker(analytics, repo, identifier, tracking);
+    } catch (error) {
+      console.warn(error);
+      return;
+    }
+  }
+  trackEvent(eventType, attributes = {}) {
+    this.tracking && this.analytics.track({
+      event: eventType,
+      ...this.identifier,
+      properties: attributes
+    });
+  }
+}
+
+function findArgument(args, name) {
+  const flagIndex = args.indexOf(`--${name}`);
+  if (flagIndex === -1)
+    return;
+  if (args.length < flagIndex + 2)
+    return;
+  const flagValue = args[flagIndex + 1];
+  if (flagValue.startsWith("--"))
+    return;
+  return flagValue;
+}
+const execCommand = util__default["default"].promisify(child_process.exec);
+
+const {
+  PRISMIC_CLIENT,
+  PRISMIC_DOM_PACKAGE_NAME,
+  PRISMIC_REACT_PACKAGE_NAME,
+  NEXT_SLICEZONE,
+  SM_PACKAGE_NAME,
+  NUXT_PRISMIC,
+  NUXT_SM,
+  VUE_SLICEZONE,
+  PRISMIC_VUE,
+  SLICE_SIMULATOR_REACT,
+  SLICE_SIMULATOR_VUE
+} = core.Utils.CONSTS;
+function depsForFramework(framework) {
+  switch (framework) {
+    case core.Models.Frameworks.react:
+      return `${PRISMIC_REACT_PACKAGE_NAME} ${PRISMIC_CLIENT}`;
+    case core.Models.Frameworks.next:
+      return `${PRISMIC_REACT_PACKAGE_NAME} ${PRISMIC_CLIENT}@v5.1.1 ${NEXT_SLICEZONE} ${SLICE_SIMULATOR_REACT}`;
+    case core.Models.Frameworks.svelte:
+      return `${PRISMIC_DOM_PACKAGE_NAME} ${PRISMIC_CLIENT}`;
+    case core.Models.Frameworks.nuxt:
+      return `${NUXT_PRISMIC} ${NUXT_SM} ${VUE_SLICEZONE} ${SLICE_SIMULATOR_VUE}`;
+    case core.Models.Frameworks.vue:
+      return `${PRISMIC_VUE} ${PRISMIC_CLIENT}@v5.1.1 ${PRISMIC_DOM_PACKAGE_NAME} ${VUE_SLICEZONE}`;
+    default:
+      return "";
+  }
+}
+async function installRequiredDependencies(cwd, framework) {
+  const yarnLock = core.Utils.Files.exists(core.FileSystem.YarnLockPath(cwd));
+  const installDevDependencyCommand = yarnLock ? "yarn add -D" : "npm install --save-dev";
+  const installDependencyCommand = yarnLock ? "yarn add" : "npm install --save";
+  const spinner = core.Utils.spinner("Downloading Prismic Visual Builder");
+  spinner.start();
+  const { stderr } = await execCommand(`${installDevDependencyCommand} ${SM_PACKAGE_NAME}`);
+  const deps = depsForFramework(framework);
+  if (deps)
+    await execCommand(`${installDependencyCommand} ${deps}`);
+  const pathToPkg = path__default["default"].join(core.FileSystem.PackagePaths(cwd).value(), SM_PACKAGE_NAME);
+  const isPackageInstalled = core.Utils.Files.exists(pathToPkg);
+  if (isPackageInstalled || !stderr.length) {
+    spinner.succeed("The Prismic Visual Builder was installed successfully");
+    return;
+  }
+  spinner.fail();
+  core.Utils.writeWarning(`could not install ${SM_PACKAGE_NAME}. Please do it manually!`);
+}
+
+function validatePkg(cwd) {
+  const jsonPackage = core.FileSystem.retrieveJsonPackage(cwd);
+  if (!jsonPackage.exists) {
+    core.Utils.writeError(`package.json not found. Are you in the right folder?`);
+    return process.exit(-1);
+  }
+  if (!jsonPackage.content) {
+    core.Utils.writeError(`could not parse package.json.`);
+    return process.exit(-1);
+  }
+}
+
+const CREATE_REPO = "$_CREATE_REPO";
+const DEFAULT_BASE = core.Utils.CONSTS.DEFAULT_BASE;
+function prettyRepoName(address, value) {
+  const repoName = value ? core.Utils.cyan(value) : core.Utils.dim.cyan("repo-name");
+  return `${core.Utils.cyan.dim(`${address.protocol}//`)}${repoName}${core.Utils.cyan.dim(`.${address.hostname}`)}`;
+}
+async function promptForRepoName(base) {
+  const address = new URL(base);
+  core.Utils.writeInfo("The name acts as a domain/endpoint for your content repo and should be completely unique.");
+  return inquirer__namespace.prompt([
+    {
+      name: "repoName",
+      message: "Name your Prismic repository",
+      type: "input",
+      required: true,
+      transformer: (value) => prettyRepoName(address, String(value)),
+      async validate(name) {
+        const result = await core.Communication.validateRepositoryName(name, base, false);
+        return result === name || result;
+      }
+    }
+  ]).then((res) => res.repoName);
+}
+function makeReposPretty(base) {
+  return function({ name, domain, role }) {
+    const address = new URL(base);
+    address.hostname = `${domain}.${address.hostname}`;
+    if (core.Utils.roles.canUpdateCustomTypes(role) === false) {
+      return {
+        name: `${core.Utils.purple.dim("Use")} ${core.Utils.bold.dim(name)} ${core.Utils.purple.dim(`"${address.hostname}"`)}`,
+        value: domain,
+        disabled: "Unauthorized"
+      };
+    }
+    return {
+      name: `${core.Utils.purple("Use")} ${core.Utils.bold(name)} ${core.Utils.purple(`"${address.hostname}"`)}`,
+      value: name
+    };
+  };
+}
+function orderPrompts(maybeName) {
+  return (a, b) => {
+    if (a instanceof Separator__default["default"] || b instanceof Separator__default["default"])
+      return 0;
+    if (maybeName && (a.value === maybeName || b.value === maybeName))
+      return 0;
+    if (a.value === CREATE_REPO || b.value === CREATE_REPO)
+      return 0;
+    if (a.disabled && !b.disabled)
+      return 1;
+    if (!a.disabled && b.disabled)
+      return -1;
+    return 0;
+  };
+}
+function maybeStickTheRepoToTheTopOfTheList(repoName) {
+  return (acc, curr) => {
+    if (repoName && curr.value === repoName) {
+      return [curr, ...acc];
+    }
+    return [...acc, curr];
+  };
+}
+function sortReposForPrompt(repos, base, cwd) {
+  const createNew = {
+    name: `${core.Utils.purple("Create a")} ${core.Utils.bold("new")} ${core.Utils.purple("Repository")}`,
+    value: CREATE_REPO
+  };
+  const maybeConfiguredRepoName = core.FileSystem.maybeRepoNameFromSMFile(cwd, base);
+  return repos.reverse().map(makeReposPretty(base)).reduce(maybeStickTheRepoToTheTopOfTheList(maybeConfiguredRepoName), [
+    createNew
+  ]).sort(orderPrompts(maybeConfiguredRepoName));
+}
+async function maybeExistingRepo(cookies, cwd, base = DEFAULT_BASE) {
+  const token = cookie.parsePrismicAuthToken(cookies);
+  const repos = await core.Communication.listRepositories(token);
+  if (repos.length === 0) {
+    const name = await promptForRepoName(base);
+    return { existing: false, name };
+  }
+  const choices = sortReposForPrompt(repos, base, cwd);
+  const numberOfDisabledRepos = choices.filter((repo) => {
+    if (repo instanceof Separator__default["default"])
+      return false;
+    return repo.disabled;
+  }).length;
+  const res = await inquirer__namespace.prompt([
+    {
+      type: "list",
+      name: "repoName",
+      default: 0,
+      required: true,
+      message: "Connect a Prismic Repository or create a new one",
+      choices,
+      pageSize: numberOfDisabledRepos + 2 <= 7 ? 7 : numberOfDisabledRepos + 2
+    }
+  ]);
+  if (res.repoName === CREATE_REPO) {
+    const name = await promptForRepoName(base);
+    return { existing: false, name };
+  }
+  return { existing: true, name: res.repoName };
+}
+
+function createRepository(domain, framework, config) {
+  const spinner = core.Utils.spinner("Creating Prismic Repository");
+  spinner.start();
+  return core.Communication.createRepository(domain, config.cookies, framework, config.base).then((res) => {
+    const addressUrl = new URL(config.base);
+    addressUrl.hostname = `${res.data.domain || domain}.${addressUrl.hostname}`;
+    const address = addressUrl.toString();
+    spinner.succeed(`We created your new repository ${address}`);
+  }).catch((error) => {
+    spinner.fail(`Error creating repository ${domain}`);
+    if (error.message) {
+      core.Utils.writeError(error.message);
+    }
+    core.Utils.writeError(`We failed to create you new prismic repository`);
+    console.log(`Run ${core.Utils.bold("npx slicemachine init")} again!`);
+    process.exit(-1);
+  });
+}
+
+async function promptForFramework() {
+  const choices = core.Models.SupportedFrameworks.map((framework) => {
+    return {
+      name: core.Utils.Framework.fancyName(framework),
+      value: framework
+    };
+  });
+  return inquirer__namespace.prompt([
+    {
+      name: "framework",
+      type: "list",
+      message: "Select a framework to use",
+      required: true,
+      choices
+    }
+  ]).then((res) => {
+    return {
+      value: res.framework,
+      manuallyAdded: true
+    };
+  });
+}
+async function detectFramework(cwd) {
+  const failMessage = `Please run ${core.Utils.bold("npx slicemachine init")} in a Nuxt or Next.js project`;
+  const spinner = core.Utils.spinner("Detecting framework to install correct dependencies");
+  spinner.start();
+  try {
+    const maybeFramework = core.Utils.Framework.defineFramework({
+      cwd,
+      supportedFrameworks: Object.values(core.Models.Frameworks)
+    });
+    spinner.stop();
+    if (!maybeFramework || maybeFramework === core.Models.Frameworks.vanillajs) {
+      core.Utils.writeError("Framework not detected");
+      return await promptForFramework();
+    }
+    const nameToPrint = core.Utils.Framework.fancyName(maybeFramework);
+    if (!core.Utils.Framework.isFrameworkSupported(maybeFramework)) {
+      core.Utils.writeError(`${nameToPrint} is currently not supported`);
+      console.log(failMessage);
+      process.exit(1);
+    }
+    core.Utils.writeCheck(`${nameToPrint} detected`);
+    return {
+      value: maybeFramework,
+      manuallyAdded: false
+    };
+  } catch (error) {
+    spinner.fail("package.json not found");
+    if (error instanceof Error && error.message) {
+      core.Utils.writeError(error.message);
+    } else {
+      console.log(failMessage);
+    }
+    process.exit(1);
+  }
 }
-catch (error) {
-    if (error instanceof Error)
-        core_1.Utils.writeError(error.message);
+
+const UserProfile = t__namespace.exact(t__namespace.type({
+  userId: t__namespace.string,
+  shortId: t__namespace.string,
+  email: t__namespace.string,
+  firstName: t__namespace.string,
+  lastName: t__namespace.string
+}));
+async function getUserProfile(cookies, base = core.Utils.CONSTS.DEFAULT_BASE) {
+  const url = new URL(base);
+  url.hostname = `user.${url.hostname}`;
+  url.pathname = "profile";
+  const endpoint = url.toString();
+  const token = core.Utils.Cookie.parsePrismicAuthToken(cookies);
+  return axios__default["default"].get(endpoint, {
+    headers: {
+      Authorization: `Bearer Token ${token}`
+    }
+  }).then((res) => _function.pipe(UserProfile.decode(res.data), Either.fold(() => {
+    throw new Error("Can't parse user profile");
+  }, (data) => data)));
+}
+async function validateSessionAndGetProfile(base = core.Utils.CONSTS.DEFAULT_BASE) {
+  const config = core.FileSystem.PrismicSharedConfigManager.get();
+  if (!config.cookies.length)
+    return Promise.resolve(null);
+  if (base != config.base)
+    return Promise.resolve(null);
+  try {
+    const info = await core.Communication.validateSession(config.cookies, base);
+    const profile = await getUserProfile(config.cookies, base).catch(() => null);
+    if (profile == null ? void 0 : profile.shortId) {
+      core.FileSystem.PrismicSharedConfigManager.setProperties({
+        shortId: profile.shortId
+      });
+    }
+    return { info, profile };
+  } catch (e) {
+    return null;
+  }
+}
+
+async function loginOrBypass(base) {
+  const user = await validateSessionAndGetProfile(base).catch((err) => console.log(err));
+  if (user) {
+    const email = user.info.email;
+    core.Utils.writeCheck(`Logged in as ${core.Utils.bold(email)}`);
+    return user;
+  } else {
+    await core.Auth.login(base);
+    const user2 = await validateSessionAndGetProfile(base);
+    return user2;
+  }
+}
+
+function configureProject(cwd, base, repository, framework, sliceLibPath = [], tracking = true) {
+  const spinner = core.Utils.spinner(`Configuring your ${framework.value} & Prismic project...`);
+  spinner.start();
+  try {
+    const manifest = core.FileSystem.retrieveManifest(cwd);
+    const manifestUpdated = {
+      ...manifest.exists && manifest.content ? manifest.content : {},
+      apiEndpoint: core.Utils.Endpoints.buildRepositoryEndpoint(base, repository),
+      libraries: ["@/slices", ...sliceLibPath],
+      ...framework.manuallyAdded ? { framework: framework.value } : {},
+      ...!tracking ? { tracking } : {}
+    };
+    if (!manifest.exists)
+      core.FileSystem.createManifest(cwd, manifestUpdated);
     else
-        console.error(error);
+      core.FileSystem.patchManifest(cwd, manifestUpdated);
+    const pathToSlicesFolder = core.FileSystem.CustomPaths(cwd).library("slices").value();
+    if (!core.Utils.Files.exists(pathToSlicesFolder))
+      core.Utils.Files.mkdir(pathToSlicesFolder, { recursive: true });
+    core.FileSystem.addJsonPackageSmScript(cwd);
+    spinner.succeed("Project configured! Ready to start");
+  } catch (e) {
+    spinner.fail("Failed to configure your Prismic Local Builder");
+    process.exit(-1);
+  }
+}
+
+function displayFinalMessage(cwd) {
+  const yarnLock = core.Utils.Files.exists(core.FileSystem.YarnLockPath(cwd));
+  const command = `${yarnLock ? "yarn" : "npm"} run ${core.Utils.CONSTS.SCRIPT_NAME}`;
+  console.log(`${core.Utils.white("\u25A0")} Run ${core.Utils.purple(command)} to now launch your Local Builder`);
+}
+
+const Dependencies = {
+  fromPkgFormat(pkgDeps) {
+    if (!pkgDeps)
+      return;
+    return Object.entries(pkgDeps).map(([name, version]) => ({
+      name,
+      version
+    }));
+  }
+};
+function formatDeps(dependencies) {
+  return dependencies.map((dep) => {
+    if (typeof dep === "string")
+      return dep;
+    return `${dep.name}@${dep.version}`;
+  }).join(" ");
+}
+const PackageManager = {
+  get(cwd) {
+    if (core.Utils.Files.exists(core.FileSystem.YarnLockPath(cwd))) {
+      return Yarn;
+    }
+    return Npm;
+  }
+};
+const Yarn = {
+  install(dependencies) {
+    return execCommand(`yarn add ${formatDeps(dependencies)}`);
+  },
+  installDev(dependencies) {
+    return execCommand(`yarn add --dev ${formatDeps(dependencies)}`);
+  }
+};
+const Npm = {
+  install(dependencies) {
+    return execCommand(`npm i --save ${formatDeps(dependencies)}`);
+  },
+  installDev(dependencies) {
+    return execCommand(`npm i --save-dev ${formatDeps(dependencies)}`);
+  }
+};
+
+const downloadFile = async (reqUrl) => {
+  const res = await axios__default["default"].get(reqUrl, { responseType: "arraybuffer" });
+  return new Promise((resolve, reject) => {
+    if (res.status == 200) {
+      const tmpZipFile = tmp__default["default"].tmpNameSync();
+      const zip = new AdmZip__default["default"](res.data);
+      zip.extractAllTo(tmpZipFile);
+      resolve(tmpZipFile);
+    } else {
+      reject();
+    }
+  });
+};
+function toGithubSource(githubPath, branch) {
+  return `https://codeload.github.com/${githubPath}/zip/${branch}`;
+}
+async function installLib(tracker, cwd, libGithubPath, branch = "HEAD") {
+  const spinner = core.Utils.spinner(`Installing the ${libGithubPath} lib in your project...`);
+  try {
+    spinner.start();
+    const [githubUserName, githubProjectName] = libGithubPath.split("/");
+    const source = toGithubSource(libGithubPath, branch);
+    const zipFilePath = await downloadFile(source);
+    const outputFolder = `${githubProjectName}-${branch}`;
+    const projectPath = path__default["default"].join(zipFilePath, outputFolder);
+    const name = `${githubUserName}-${githubProjectName}`;
+    const libDestinationFolder = path__default["default"].join(cwd, name);
+    if (fs__default["default"].existsSync(libDestinationFolder)) {
+      spinner.succeed(`Lib "${libGithubPath}" was already installed (skipped)`);
+      return;
+    }
+    fsExtra__default["default"].moveSync(path__default["default"].join(projectPath, "src"), libDestinationFolder);
+    const pkgManager = PackageManager.get(cwd);
+    const pkgJson = PackageJson.PackageJsonHelper.fromPath(path__default["default"].join(projectPath, "package.json"));
+    if (pkgJson instanceof Error)
+      throw pkgJson;
+    const dependencies = Dependencies.fromPkgFormat(pkgJson.dependencies);
+    if (dependencies)
+      await pkgManager.install(dependencies);
+    Files__default["default"].write(path__default["default"].join(libDestinationFolder, "meta.json"), {
+      name: pkgJson.name
+    });
+    const manifest = Files__default["default"].readEntity(path__default["default"].join(projectPath, "sm.json"), (payload) => {
+      return Either.getOrElseW(() => new Error(`Unable to parse sm.json from lib ${libGithubPath}`))(Manifest.Manifest.decode(payload));
+    });
+    if (manifest instanceof Error)
+      throw manifest;
+    const localLibs = Manifest.ManifestHelper.localLibraries(manifest).map(({ path: path2 }) => {
+      return `~/${name}/${path2.replace("src/", "")}`;
+    });
+    spinner.succeed(`Slice library "${libGithubPath}" was installed successfully`);
+    tracker == null ? void 0 : tracker.Track.downloadLibrary(libGithubPath);
+    return localLibs;
+  } catch (error) {
+    spinner.fail(`Error installing ${libGithubPath} lib!`);
+    if (error instanceof Error) {
+      console.error(error.message);
+    }
+    process.exit(-1);
+  }
+}
+
+async function init() {
+  var _a;
+  const cwd = findArgument(process.argv, "cwd") || process.cwd();
+  const base = findArgument(process.argv, "base") || core.Utils.CONSTS.DEFAULT_BASE;
+  const lib = findArgument(process.argv, "library");
+  const branch = findArgument(process.argv, "branch");
+  const isTrackingAvailable = findArgument(process.argv, "tracking") === "false" ? false : true;
+  console.log(core.Utils.purple("You're about to configure Slicemachine... Press ctrl + C to cancel"));
+  validatePkg(cwd);
+  const user = await loginOrBypass(base);
+  if (!user)
+    throw new Error("The user should be logged in!");
+  const config = core.FileSystem.PrismicSharedConfigManager.get();
+  const frameworkResult = await detectFramework(cwd);
+  const { existing, name } = await maybeExistingRepo(config.cookies, cwd, config.base);
+  if (!existing) {
+    await createRepository(name, frameworkResult.value, config);
+  }
+  const tracker = ((_a = user.profile) == null ? void 0 : _a.shortId) ? Tracker.build("JfTfmHaATChc4xueS7RcCBsixI71dJIJ" , name, {
+    userId: user.profile.shortId
+  }, isTrackingAvailable) : void 0;
+  await installRequiredDependencies(cwd, frameworkResult.value);
+  const sliceLibPath = lib ? await installLib(tracker, cwd, lib, branch) : void 0;
+  configureProject(cwd, base, name, frameworkResult, sliceLibPath, isTrackingAvailable);
+  displayFinalMessage(cwd);
+}
+try {
+  void init();
+} catch (error) {
+  if (error instanceof Error)
+    core.Utils.writeError(error.message);
+  else
+    console.error(error);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUEsNkNBQXVEO0FBQ3ZELG1DQVNpQjtBQUNqQixtQ0FBdUM7QUFFdkMsS0FBSyxVQUFVLElBQUk7SUFDakIsTUFBTSxHQUFHLEdBQUcsSUFBQSxvQkFBWSxFQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsS0FBSyxDQUFDLElBQUksT0FBTyxDQUFDLEdBQUcsRUFBRSxDQUFDO0lBQy9ELE1BQU0sSUFBSSxHQUFHLElBQUEsb0JBQVksRUFBQyxPQUFPLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxJQUFJLFlBQUssQ0FBQyxNQUFNLENBQUMsWUFBWSxDQUFDO0lBRTdFLE9BQU8sQ0FBQyxHQUFHLENBQ1QsWUFBSyxDQUFDLE1BQU0sQ0FDVixvRUFBb0UsQ0FDckUsQ0FDRixDQUFDO0lBR0YsSUFBQSxtQkFBVyxFQUFDLEdBQUcsQ0FBQyxDQUFDO0lBR2pCLE1BQU0sSUFBQSxxQkFBYSxFQUFDLElBQUksQ0FBQyxDQUFDO0lBRzFCLE1BQU0sTUFBTSxHQUFHLGlCQUFVLENBQUMsMEJBQTBCLENBQUMsR0FBRyxFQUFFLENBQUM7SUFHM0QsTUFBTSxlQUFlLEdBQUcsTUFBTSxJQUFBLHVCQUFlLEVBQUMsR0FBRyxDQUFDLENBQUM7SUFHbkQsTUFBTSxFQUFFLFFBQVEsRUFBRSxJQUFJLEVBQUUsR0FBRyxNQUFNLElBQUEseUJBQWlCLEVBQ2hELE1BQU0sQ0FBQyxPQUFPLEVBQ2QsR0FBRyxFQUNILE1BQU0sQ0FBQyxJQUFJLENBQ1osQ0FBQztJQUVGLElBQUksQ0FBQyxRQUFRLEVBQUU7UUFDYixNQUFNLElBQUEsd0JBQWdCLEVBQUMsSUFBSSxFQUFFLGVBQWUsQ0FBQyxLQUFLLEVBQUUsTUFBTSxDQUFDLENBQUM7S0FDN0Q7SUFHRCxNQUFNLElBQUEsbUNBQTJCLEVBQUMsR0FBRyxFQUFFLGVBQWUsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUc5RCxJQUFBLHdCQUFnQixFQUFDLEdBQUcsRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLGVBQWUsQ0FBQyxDQUFDO0lBR25ELElBQUEsMkJBQW1CLEVBQUMsR0FBRyxDQUFDLENBQUM7QUFDM0IsQ0FBQztBQUVELElBQUk7SUFDRixLQUFLLElBQUksRUFBRSxDQUFDO0NBQ2I7QUFBQyxPQUFPLEtBQUssRUFBRTtJQUNkLElBQUksS0FBSyxZQUFZLEtBQUs7UUFBRSxZQUFLLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQzs7UUFDdkQsT0FBTyxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztDQUMzQiJ9
+//# sourceMappingURL=index.js.map