@charcoal-ui/icons-cli 1.0.0-alpha.1

package/dist/index.module.js

@@ -0,0 +1,889 @@
+import { remove, ensureDir, ensureFile, writeFile, readFile } from 'fs-extra';
+import yargs from 'yargs';
+import path from 'path';
+import camelCase from 'camelcase';
+import Figma from 'figma-js';
+import got from 'got';
+import { match } from 'path-to-regexp';
+import PQueue from 'p-queue';
+import { Octokit } from '@octokit/rest';
+import { promises } from 'fs';
+import { exec } from 'child_process';
+import { Gitlab } from '@gitbeaker/node';
+import { JSDOM } from 'jsdom';
+import { parseToRgb } from 'polished';
+import Svgo from 'svgo';
+
+function concurrently(tasks) {
+  const queue = new PQueue({
+    concurrency: 3
+  });
+
+  for (const task of tasks) {
+    void queue.add(task);
+  }
+
+  queue.start();
+  return queue.onIdle();
+}
+
+const extracter = match('/file/:file/:name');
+
+function extractFileId(url) {
+  const result = extracter(new URL(url).pathname);
+
+  if (result === false) {
+    throw new Error('no :file in url');
+  }
+
+  return result.params.file;
+}
+
+function extractNodeId(url) {
+  if (!url.includes('?')) {
+    return undefined;
+  }
+
+  const [, query] = url.split('?');
+  const params = new URLSearchParams(query);
+  const nodeId = params.get('node-id');
+
+  if (nodeId === null) {
+    return undefined;
+  }
+
+  return decodeURIComponent(nodeId);
+}
+
+function filenamify(name) {
+  return camelCase(name, {
+    pascalCase: true
+  }).replace(' ', '');
+} // eslint-disable-next-line prefer-named-capture-group
+
+
+const iconName = /^(\d|Inline)+\s*\/\s*/u;
+
+function isIconNode(node) {
+  return iconName.test(node.name);
+}
+
+function getContentType(exportFormat) {
+  switch (exportFormat) {
+    case 'svg':
+      return 'image/svg+xml';
+
+    case 'pdf':
+      return 'application/pdf';
+  }
+}
+
+class FigmaFileClient {
+  static async runFromCli(url, token, outputRootDir, exportFormat) {
+    const client = new this(url, token, exportFormat);
+    const root = process.cwd();
+    const outputDir = path.join(root, outputRootDir, exportFormat);
+    console.log(`Exporting ${url} components`);
+    await client.loadSvg(outputDir);
+    console.log(`Exporting components type`);
+    const typedefDir = path.join(root, outputRootDir, 'src');
+    await client.writeTypeDef(typedefDir);
+    console.log('success!');
+  }
+
+  constructor(url, personalAccessToken, exportFormat) {
+    this.fileId = void 0;
+    this.nodeId = void 0;
+    this.exportFormat = void 0;
+    this.client = void 0;
+    this.components = {};
+    this.targets = [];
+    this.client = Figma.Client({
+      personalAccessToken
+    });
+    this.fileId = extractFileId(url);
+    this.nodeId = extractNodeId(url);
+    this.exportFormat = exportFormat;
+  }
+
+  async loadSvg(outputDir) {
+    await remove(outputDir);
+    await ensureDir(outputDir);
+    await this.loadComponents();
+    await this.loadImageUrls();
+    await this.downloadImages(outputDir);
+  }
+  /**
+   * Generate union of file names for typing
+   */
+
+
+  async writeTypeDef(outputDir) {
+    const fullname = path.resolve(outputDir, 'filenames.ts');
+    const KNOWN_ICON_FILES = Object.values(this.components).map(({
+      name
+    }) => filenamify(name));
+    console.log(`writing to ${outputDir}`);
+    await ensureFile(fullname);
+    await writeFile(fullname, `/** This file is auto generated. DO NOT EDIT BY HAND. */
+
+/* eslint-disable */
+
+// prettier-ignore
+export const KNOWN_ICON_FILES = ${JSON.stringify(KNOWN_ICON_FILES)} as const;
+
+export type KnownIconFile = typeof KNOWN_ICON_FILES[number];
+
+/* eslint-enable */
+`, {
+      encoding: 'utf8'
+    });
+  }
+
+  async loadComponents() {
+    const {
+      document
+    } = await this.getFile();
+    this.targets = document.children.filter(node => {
+      if (this.nodeId !== undefined) {
+        return node.id === this.nodeId;
+      }
+
+      return false;
+    });
+    this.targets.forEach(child => this.findComponentsRecursively(child));
+
+    if (Object.values(this.targets).length === 0) {
+      throw new Error('No components found!');
+    }
+  }
+
+  async loadImageUrls() {
+    console.log('Getting export urls');
+    const {
+      data
+    } = await this.client.fileImages(this.fileId, {
+      format: this.exportFormat,
+      ids: Object.keys(this.components),
+      scale: 1
+    });
+
+    for (const [id, image] of Object.entries(data.images)) {
+      this.components[id].image = image;
+    }
+  }
+
+  async downloadImages(outputDir) {
+    return concurrently(Object.values(this.components).map(component => async () => {
+      if (component.image === undefined) {
+        return;
+      }
+
+      const response = await got.get(component.image, {
+        headers: {
+          'Content-Type': getContentType(this.exportFormat)
+        },
+        encoding: 'utf8'
+      });
+      const filename = `${filenamify(component.name)}.${this.exportFormat}`;
+      const fullname = path.join(outputDir, filename);
+      const dirname = path.dirname(fullname);
+      await ensureDir(dirname);
+      console.log(`found: ${filename} => ✅ writing...`);
+      await writeFile(fullname, response.body, 'utf8');
+    }));
+  }
+
+  async getFile() {
+    console.log('Processing response');
+    const {
+      data
+    } = await this.client.file(this.fileId.toString());
+    return data;
+  }
+
+  findComponentsRecursively(child) {
+    if (child.type === 'COMPONENT') {
+      const {
+        name,
+        id
+      } = child;
+
+      if (isIconNode(child)) {
+        this.components[id] = {
+          name,
+          id
+        };
+      }
+    } else if ('children' in child) {
+      child.children.forEach(grandChild => this.findComponentsRecursively(grandChild));
+    }
+  }
+
+}
+
+function _asyncIterator(iterable) {
+  var method,
+      async,
+      sync,
+      retry = 2;
+
+  for ("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;) {
+    if (async && null != (method = iterable[async])) return method.call(iterable);
+    if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));
+    async = "@@asyncIterator", sync = "@@iterator";
+  }
+
+  throw new TypeError("Object is not async iterable");
+}
+
+function AsyncFromSyncIterator(s) {
+  function AsyncFromSyncIteratorContinuation(r) {
+    if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
+    var done = r.done;
+    return Promise.resolve(r.value).then(function (value) {
+      return {
+        value: value,
+        done: done
+      };
+    });
+  }
+
+  return AsyncFromSyncIterator = function (s) {
+    this.s = s, this.n = s.next;
+  }, AsyncFromSyncIterator.prototype = {
+    s: null,
+    n: null,
+    next: function () {
+      return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+    },
+    return: function (value) {
+      var ret = this.s.return;
+      return void 0 === ret ? Promise.resolve({
+        value: value,
+        done: !0
+      }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
+    },
+    throw: function (value) {
+      var thr = this.s.return;
+      return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
+    }
+  }, new AsyncFromSyncIterator(s);
+}
+
+function _AwaitValue(value) {
+  this.wrapped = value;
+}
+
+function _AsyncGenerator(gen) {
+  var front, back;
+
+  function send(key, arg) {
+    return new Promise(function (resolve, reject) {
+      var request = {
+        key: key,
+        arg: arg,
+        resolve: resolve,
+        reject: reject,
+        next: null
+      };
+
+      if (back) {
+        back = back.next = request;
+      } else {
+        front = back = request;
+        resume(key, arg);
+      }
+    });
+  }
+
+  function resume(key, arg) {
+    try {
+      var result = gen[key](arg);
+      var value = result.value;
+      var wrappedAwait = value instanceof _AwaitValue;
+      Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) {
+        if (wrappedAwait) {
+          resume(key === "return" ? "return" : "next", arg);
+          return;
+        }
+
+        settle(result.done ? "return" : "normal", arg);
+      }, function (err) {
+        resume("throw", err);
+      });
+    } catch (err) {
+      settle("throw", err);
+    }
+  }
+
+  function settle(type, value) {
+    switch (type) {
+      case "return":
+        front.resolve({
+          value: value,
+          done: true
+        });
+        break;
+
+      case "throw":
+        front.reject(value);
+        break;
+
+      default:
+        front.resolve({
+          value: value,
+          done: false
+        });
+        break;
+    }
+
+    front = front.next;
+
+    if (front) {
+      resume(front.key, front.arg);
+    } else {
+      back = null;
+    }
+  }
+
+  this._invoke = send;
+
+  if (typeof gen.return !== "function") {
+    this.return = undefined;
+  }
+}
+
+_AsyncGenerator.prototype[typeof Symbol === "function" && Symbol.asyncIterator || "@@asyncIterator"] = function () {
+  return this;
+};
+
+_AsyncGenerator.prototype.next = function (arg) {
+  return this._invoke("next", arg);
+};
+
+_AsyncGenerator.prototype.throw = function (arg) {
+  return this._invoke("throw", arg);
+};
+
+_AsyncGenerator.prototype.return = function (arg) {
+  return this._invoke("return", arg);
+};
+
+function _wrapAsyncGenerator(fn) {
+  return function () {
+    return new _AsyncGenerator(fn.apply(this, arguments));
+  };
+}
+
+function _awaitAsyncGenerator(value) {
+  return new _AwaitValue(value);
+}
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+/**
+ * FIXME: util.promisify を使うと node-libs-browser に入っている方が使われてしまい、壊れる
+ */
+
+const execp = command => new Promise((resolve, reject) => {
+  exec(command, (err, stdout) => {
+    if (err) {
+      return reject(err);
+    }
+
+    return resolve(stdout);
+  });
+});
+function mustBeDefined(value, name) {
+  if (typeof value === 'undefined') {
+    throw new TypeError(`${name} must be defined.`);
+  }
+}
+
+const targetDir = path.resolve(process.cwd(), 'packages', 'icons', 'svg');
+/**
+ * dir 内で変更があったファイル情報を for await で回せるようにするやつ
+ */
+
+function getChangedFiles() {
+  return _getChangedFiles.apply(this, arguments);
+}
+
+function _getChangedFiles() {
+  _getChangedFiles = _wrapAsyncGenerator(function* (dir = targetDir) {
+    const directories = yield _awaitAsyncGenerator(promises.readdir(dir));
+    const gitStatus = yield _awaitAsyncGenerator(collectGitStatus());
+
+    for (const dir of directories) {
+      const directory = path.resolve(targetDir, dir); // eslint-disable-next-line no-await-in-loop
+
+      const stat = yield _awaitAsyncGenerator(promises.stat(directory));
+
+      if (!stat.isDirectory()) {
+        continue;
+      } // eslint-disable-next-line no-await-in-loop
+
+
+      const files = yield _awaitAsyncGenerator(promises.readdir(directory));
+
+      for (const file of files) {
+        const fullpath = path.resolve(targetDir, dir, file);
+        const relativePath = path.relative(process.cwd(), fullpath);
+        const status = gitStatus[relativePath];
+
+        if (status == null) {
+          // Already up-to-date
+          continue;
+        } // eslint-disable-next-line no-await-in-loop
+
+
+        const content = yield _awaitAsyncGenerator(promises.readFile(fullpath, {
+          encoding: 'utf-8'
+        }));
+        yield {
+          relativePath,
+          content,
+          status
+        };
+      }
+    }
+  });
+  return _getChangedFiles.apply(this, arguments);
+}
+
+async function collectGitStatus() {
+  return Object.fromEntries(
+  /**
+   * @see https://git-scm.com/docs/git-status#_porcelain_format_version_1
+   */
+  (await execp(`git status --porcelain`)).split('\n').map(s => [s.slice(3), s.startsWith(' M') ? 'modified' : s.startsWith('??') ? 'untracked' : s.startsWith(' D') ? 'deleted' : null]));
+}
+
+class GithubClient {
+  static async runFromCli(repoOwner, repoName, token, defaultBranch) {
+    const client = new this(repoOwner, repoName, token, defaultBranch);
+    const diff = await client.createTreeFromDiff();
+    console.log(`${diff.length} files are changed`);
+
+    if (diff.length === 0) {
+      console.log('no changes. aborting');
+      return;
+    }
+
+    const newBranch = await client.createBranch();
+    await client.createCommit(diff, newBranch);
+    return client.createPullRequest(newBranch);
+  }
+
+  constructor(repoOwner, repoName, token, defaultBranch, now = new Date()) {
+    this.repoOwner = void 0;
+    this.repoName = void 0;
+    this.defaultBranch = void 0;
+    this.api = void 0;
+    this.now = void 0;
+    this.repoOwner = repoOwner;
+    this.repoName = repoName;
+    this.defaultBranch = defaultBranch;
+    this.api = new Octokit({
+      auth: token
+    });
+    this.now = now;
+  }
+
+  get branch() {
+    return `icons/update/${this.now.getTime()}`;
+  }
+  /**
+   * both used for commit message or pull request title
+   */
+
+
+  get message() {
+    return `[icons-cli] Update icons ${this.now.toDateString()}`;
+  }
+
+  async createTreeFromDiff() {
+    const tree = [];
+    var _iteratorAbruptCompletion = false;
+    var _didIteratorError = false;
+
+    var _iteratorError;
+
+    try {
+      for (var _iterator = _asyncIterator(getChangedFiles()), _step; _iteratorAbruptCompletion = !(_step = await _iterator.next()).done; _iteratorAbruptCompletion = false) {
+        const file = _step.value;
+        const item = {
+          path: file.relativePath,
+          // 100 はファイル 644 は実行不可なファイルであるという意味
+          // @see https://octokit.github.io/rest.js/v18#git-create-tree
+          mode: '100644',
+          content: file.content
+        };
+
+        if (file.status === 'deleted') {
+          // https://stackoverflow.com/questions/23637961/how-do-i-mark-a-file-as-deleted-in-a-tree-using-the-github-api
+          tree.push(_extends({}, item, {
+            sha: null
+          }));
+        } else {
+          tree.push(item);
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (_iteratorAbruptCompletion && _iterator.return != null) {
+          await _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+
+    return tree;
+  }
+
+  async createCommit(tree, targetBranch) {
+    const parentCommit = await this.api.git.getCommit({
+      owner: this.repoOwner,
+      repo: this.repoName,
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      commit_sha: targetBranch.data.object.sha
+    });
+    const newTree = await this.api.git.createTree({
+      owner: this.repoOwner,
+      repo: this.repoName,
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      base_tree: parentCommit.data.tree.sha,
+      tree
+    }); // この時点ではどのブランチにも属さないコミットができる
+
+    const commit = await this.api.git.createCommit({
+      owner: this.repoOwner,
+      repo: this.repoName,
+      message: this.message,
+      tree: newTree.data.sha,
+      parents: [parentCommit.data.sha]
+    }); // ref を更新することで、commit が targetBranch に属するようになる
+
+    await this.api.git.updateRef({
+      owner: this.repoOwner,
+      repo: this.repoName,
+      ref: `heads/${this.branch}`,
+      sha: commit.data.sha
+    });
+    return commit;
+  }
+
+  async createPullRequest(targetBranch) {
+    const defaultBranch = await this.getDefaultBranchRef();
+    return this.api.pulls.create({
+      owner: this.repoOwner,
+      repo: this.repoName,
+      head: targetBranch.data.ref,
+      base: defaultBranch.data.ref,
+      title: this.message,
+      body: ''
+    });
+  }
+
+  getDefaultBranchRef() {
+    return this.api.git.getRef({
+      owner: this.repoOwner,
+      repo: this.repoName,
+      ref: `heads/${this.defaultBranch}`
+    });
+  }
+
+  async createBranch() {
+    const defaultBranch = await this.getDefaultBranchRef();
+    return this.api.git.createRef({
+      owner: this.repoOwner,
+      repo: this.repoName,
+      ref: `refs/heads/${this.branch}`,
+      sha: defaultBranch.data.object.sha
+    });
+  }
+
+}
+
+class GitlabClient {
+  static async runFromCli(host, projectId, privateToken, defaultBranch) {
+    const client = new this(host, projectId, privateToken, defaultBranch);
+    const diff = await client.createActionsFromDiff();
+    console.log(`${diff.length} files are changed`);
+
+    if (diff.length === 0) {
+      console.log('no changes. aborting');
+      return;
+    }
+
+    await client.createCommit(diff);
+    return client.createMergeRequest();
+  }
+
+  constructor(host, projectId, privateToken, defaultBranch, now = new Date()) {
+    this.host = void 0;
+    this.projectId = void 0;
+    this.defaultBranch = void 0;
+    this.api = void 0;
+    this.now = void 0;
+    this.host = host;
+    this.projectId = projectId;
+    this.defaultBranch = defaultBranch;
+    this.api = new Gitlab({
+      host: this.host,
+      token: privateToken
+    });
+    this.now = now;
+  }
+
+  get branch() {
+    return `icons/update/${this.now.getTime()}`;
+  }
+  /**
+   * both used for commit message or merge request title
+   */
+
+
+  get message() {
+    return `[icons-cli] Update icons ${this.now.toDateString()}`;
+  }
+
+  async createActionsFromDiff() {
+    const actions = [];
+    var _iteratorAbruptCompletion = false;
+    var _didIteratorError = false;
+
+    var _iteratorError;
+
+    try {
+      for (var _iterator = _asyncIterator(getChangedFiles()), _step; _iteratorAbruptCompletion = !(_step = await _iterator.next()).done; _iteratorAbruptCompletion = false) {
+        const file = _step.value;
+        actions.push({
+          action: file.status === 'untracked' ? 'create' : file.status === 'deleted' ? 'delete' : 'update',
+          filePath: file.relativePath,
+          content: file.content
+        });
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (_iteratorAbruptCompletion && _iterator.return != null) {
+          await _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+
+    return actions;
+  }
+
+  async createCommit(diff) {
+    return this.api.Commits.create(this.projectId, this.branch, this.message, diff, {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      start_branch: this.defaultBranch
+    });
+  }
+
+  createMergeRequest() {
+    return this.api.MergeRequests.create(this.projectId, this.branch, this.defaultBranch, this.message);
+  }
+
+}
+
+const DEFAULT_CURRENT_COLOR_TARGET = '#858585';
+const svgo = new Svgo({
+  plugins: [// NOTICE: SVGO は「svg 内のすべての fill を currentColor に変える」機能しかない
+  // icons-cli に必要なのは「特定の黒っぽい色だけ currentColor に変える」機能
+  // なので、convertColors plugin は使わない
+  // { convertColors: { currentColor: true } },
+  {
+    removeViewBox: true
+  }, {
+    removeAttrs: {
+      attrs: ['stroke-opacity', 'fill-opacity']
+    }
+  }]
+});
+async function optimizeSvg(input, convertedColor) {
+  const {
+    data
+  } = await svgo.optimize(input);
+  const {
+    document
+  } = new JSDOM(data).window;
+  const svg = document.querySelector('svg');
+
+  if (!svg) {
+    throw new Error('optimizeSvg: input string seems not to have <svg>');
+  }
+
+  addViewboxToRootSvg(svg);
+  convertToCurrentColor(svg, convertedColor);
+  return svg.outerHTML;
+}
+const TARGET_ATTRS = ['fill', 'stroke'];
+
+function convertToCurrentColor(svg, convertedColor) {
+  const targetColor = parseColor(convertedColor);
+
+  if (!targetColor) {
+    throw new Error(`${convertedColor} is not a valid color`);
+  }
+
+  for (const attr of TARGET_ATTRS) {
+    const targets = Array.from(svg.querySelectorAll(`[${attr}]`));
+
+    for (const el of targets) {
+      const value = parseColor(el.getAttribute(attr));
+
+      if (!value) {
+        continue;
+      }
+
+      if (!colorEquals(value, targetColor)) {
+        continue;
+      }
+
+      el.setAttribute(attr, 'currentColor');
+    }
+  }
+}
+
+function parseColor(value) {
+  if (value == null) {
+    return null;
+  }
+
+  try {
+    return parseToRgb(value);
+  } catch (_unused) {
+    return null;
+  }
+}
+
+function colorEquals(self, other) {
+  if (self.red !== other.red) {
+    return false;
+  }
+
+  if (self.blue !== other.blue) {
+    return false;
+  }
+
+  if (self.green !== other.green) {
+    return false;
+  }
+
+  if ('alpha' in self) {
+    if ('alpha' in other) {
+      if (self.alpha !== other.alpha) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+function addViewboxToRootSvg(svg) {
+  const width = svg.getAttribute('width');
+  const height = svg.getAttribute('height');
+  svg.setAttribute('viewBox', `0 0 ${width} ${height}`);
+}
+
+/**
+ * Figma
+ */
+
+const FIGMA_TOKEN = process.env.FIGMA_TOKEN;
+const FIGMA_FILE_URL = process.env.FIGMA_FILE_URL;
+const OUTPUT_ROOT_DIR = process.env.OUTPUT_ROOT_DIR;
+/**
+ * GitLab
+ */
+
+const GITLAB_ACCESS_TOKEN = process.env.GITLAB_ACCESS_TOKEN;
+const GITLAB_DEFAULT_BRANCH = process.env.GITLAB_DEFAULT_BRANCH;
+const GITLAB_HOST = process.env.GITLAB_HOST;
+const GITLAB_PROJECT_ID = process.env.GITLAB_PROJECT_ID;
+/**
+ * GitHub
+ */
+
+const GITHUB_ACCESS_TOKEN = process.env.GITHUB_ACCESS_TOKEN;
+const GITHUB_REPO_OWNER = process.env.GITHUB_REPO_OWNER;
+const GITHUB_REPO_NAME = process.env.GITHUB_REPO_NAME;
+const GITHUB_DEFAULT_BRANCH = process.env.GITHUB_DEFAULT_BRANCH;
+void yargs.scriptName('icons-cli').command('figma:export', 'Load all icons from Figma and save to files', () => yargs.option('format', {
+  default: 'svg',
+  choices: ['svg', 'pdf']
+}), ({
+  format
+}) => {
+  mustBeDefined(FIGMA_FILE_URL, 'FIGMA_FILE_URL');
+  mustBeDefined(FIGMA_TOKEN, 'FIGMA_TOKEN');
+  mustBeDefined(OUTPUT_ROOT_DIR, 'OUTPUT_ROOT_DIR');
+  void FigmaFileClient.runFromCli(FIGMA_FILE_URL, FIGMA_TOKEN, OUTPUT_ROOT_DIR, format).catch(e => {
+    console.error(e);
+    process.exit(1);
+  });
+}).command('svg:optimize', 'Optimize given .svg files and overwrite it', () => yargs.option('file', {
+  demandOption: true,
+  type: 'string'
+}).option('color', {
+  default: DEFAULT_CURRENT_COLOR_TARGET,
+  type: 'string',
+  defaultDescription: 'Color code that should be converted into `currentColor`'
+}), ({
+  file,
+  color
+}) => {
+  void readFile(file, {
+    encoding: 'utf-8'
+  }).then(content => optimizeSvg(content, color)).then(optimized => writeFile(file, optimized)).catch(e => {
+    console.error(e);
+    process.exit(1);
+  });
+}).command('gitlab:mr', 'Create a merge request in the name of icons-cli', {}, () => {
+  mustBeDefined(GITLAB_PROJECT_ID, 'GITLAB_PROJECT_ID');
+  mustBeDefined(GITLAB_ACCESS_TOKEN, 'GITLAB_ACCESS_TOKEN');
+  void GitlabClient.runFromCli(GITLAB_HOST != null ? GITLAB_HOST : 'https://gitlab.com', Number(GITLAB_PROJECT_ID), GITLAB_ACCESS_TOKEN, GITLAB_DEFAULT_BRANCH != null ? GITLAB_DEFAULT_BRANCH : 'main').catch(e => {
+    console.error(e);
+    process.exit(1);
+  });
+}).command('github:pr', 'Create a pull request in the name of icons-cli', {}, () => {
+  mustBeDefined(GITHUB_ACCESS_TOKEN, 'GITHUB_ACCESS_TOKEN');
+  void GithubClient.runFromCli(GITHUB_REPO_OWNER != null ? GITHUB_REPO_OWNER : 'pixiv', GITHUB_REPO_NAME != null ? GITHUB_REPO_NAME : 'charcoal', GITHUB_ACCESS_TOKEN, GITHUB_DEFAULT_BRANCH != null ? GITHUB_DEFAULT_BRANCH : 'main').catch(e => {
+    console.error(e);
+    process.exit(1);
+  });
+}).demandCommand().help().parse();
+//# sourceMappingURL=index.module.js.map