fabric 5.3.0 → 6.0.0-beta3

package/rollup.test.config.js

@@ -0,0 +1,24 @@
+import commonjs from '@rollup/plugin-commonjs';
+import ts from 'rollup-plugin-ts';
+
+// https://github.com/artberri/rollup-plugin-istanbul
+
+// https://rollupjs.org/guide/en/#configuration-files
+export default {
+  external: ['qunit', 'fabric'],
+  input: ['test/unit/index.ts', 'test/visual/index.ts'],
+  output: [
+    {
+      dir: 'cli_output/test',
+      format: 'cjs',
+      exports: 'named',
+      preserveModules: true, // Keep directory structure and files
+    },
+  ],
+  plugins: [
+    ts({
+      /* Plugin options */
+    }),
+    commonjs(),
+  ],
+};

package/scripts/build.mjs

@@ -0,0 +1,50 @@
+import cp from 'child_process';
+import path from 'node:path';
+import process from 'node:process';
+import { wd } from './dirname.mjs';
+
+/**
+ * Handles rollup build
+ *
+ * Hooks to build events to create `cli_output/build-lock.json`
+ * @see https://rollupjs.org/guide/en/#--watchonstart-cmd---watchonbundlestart-cmd---watchonbundleend-cmd---watchonend-cmd---watchonerror-cmd
+ * @param {*} options
+ */
+export function build({ watch, fast, input, output, stats = false } = {}) {
+  const cmd = [
+    'rollup',
+    '-c',
+    watch ? '--watch' : '',
+    '--no-watch.clearScreen',
+    ...['onStart', 'onError', 'onEnd'].map(
+      (type) =>
+        `--watch.${type} "node ./scripts/buildReporter.mjs ${type
+          .toLowerCase()
+          .slice(2)}"`
+    ),
+  ].join(' ');
+  const processOptions = {
+    stdio: 'inherit',
+    shell: true,
+    cwd: wd,
+    env: {
+      ...process.env,
+      MINIFY: Number(!fast),
+      BUILD_INPUT: Array.isArray(input) ? input.join(' ') : input,
+      BUILD_OUTPUT: output,
+      BUILD_STATS: Number(stats),
+    },
+  };
+  if (watch) {
+    cp.spawn(cmd, processOptions);
+  } else {
+    try {
+      cp.execSync(cmd, processOptions);
+    } catch (error) {
+      // minimal logging, no need for stack trace
+      console.error(error.message);
+      // inform ci
+      process.exit(1);
+    }
+  }
+}

package/scripts/buildLock.mjs

@@ -0,0 +1,115 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import _ from 'lodash';
+import moment from 'moment';
+import path from 'node:path';
+import process from 'node:process';
+import psList from 'ps-list';
+import { dumpsPath } from './dirname.mjs';
+
+export const lockFile = path.resolve(dumpsPath, 'build-lock.json');
+
+/**
+ *
+ * @returns {{start:{pid:number,timestamp:string},error?:{pid:number,timestamp:string}} | null}
+ */
+function readLockFile() {
+  return fs.existsSync(lockFile) ? JSON.parse(fs.readFileSync(lockFile)) : null;
+}
+
+/**
+ * For concurrency reasons, the last process to lock is granted permission to unlock.
+ * If the process died the next process to try to unlock will be granted permission.
+ */
+export async function unlock() {
+  const lock = readLockFile();
+  if (!lock) return;
+  const lockPID = lock.start.pid;
+  const hasPermissionToUnlock =
+    process.pid === lockPID ||
+    !(await psList()).find(({ pid }) => pid === lockPID);
+  try {
+    hasPermissionToUnlock && fs.unlinkSync(lockFile);
+  } catch (error) {}
+}
+
+export function isLocked() {
+  return fs.existsSync(lockFile);
+}
+
+export function awaitBuild() {
+  return new Promise((resolve) => {
+    if (isLocked()) {
+      console.log(chalk.cyanBright('> waiting for build to finish...'));
+      const watcher = subscribe((locked) => {
+        if (!locked) {
+          watcher.close();
+          resolve();
+        }
+      }, 500);
+    } else {
+      resolve();
+    }
+  });
+}
+
+/**
+ * Subscribe to build start/error/completion.
+ *
+ * @param {(locked: boolean, error: boolean) => any} cb
+ * @param {number} [debounce]
+ * @returns
+ */
+export function subscribe(cb, debounce) {
+  return fs.watch(
+    path.dirname(lockFile),
+    _.debounce((type, file) => {
+      if (file !== path.basename(lockFile)) return;
+      cb(isLocked(), !!(readLockFile() ?? {}).error);
+    }, debounce)
+  );
+}
+
+/**
+ *
+ * @param {'start'|'error'|'end'} type
+ * @param {*} [data]
+ */
+export function report(type, data) {
+  switch (type) {
+    case 'start':
+      fs.writeFileSync(
+        lockFile,
+        JSON.stringify(
+          {
+            start: {
+              timestamp: moment().format('YYYY-MM-DD HH:mm:ss'),
+              pid: process.pid,
+            },
+          },
+          null,
+          '\t'
+        )
+      );
+      break;
+    case 'error':
+      fs.writeFileSync(
+        lockFile,
+        JSON.stringify(
+          {
+            ...readLockFile(),
+            error: {
+              timestamp: moment().format('YYYY-MM-DD HH:mm:ss'),
+              pid: process.pid,
+              data,
+            },
+          },
+          null,
+          '\t'
+        )
+      );
+      break;
+    case 'end':
+      isLocked() && !readLockFile().error && unlock();
+  }
+}

package/scripts/buildReporter.mjs

@@ -0,0 +1,15 @@
+/**
+ * This file is used by `./build` to create `cli_output/build-lock.json`
+ */
+
+import { Command } from 'commander';
+import { report } from './buildLock.mjs';
+
+const program = new Command();
+
+program
+  .command('report <type>', { isDefault: true })
+  .action((type) => {
+    report(type);
+  })
+  .parse(process.argv);

package/scripts/buildStats.mjs

@@ -0,0 +1,139 @@
+const REQUESTED_COMMENTS_PER_PAGE = 20;
+
+const COMMENT_MARKER = '<!-- BUILD STATS COMMENT -->';
+
+const MAX_COMMENT_CHARS = 65536;
+
+function printSize(a, b) {
+  const diff = b - a;
+  return `${b.toFixed(3)} (**${Math.sign(diff) > 0 ? '+' : ''}${diff.toFixed(
+    diff !== 0 ? 3 : 0
+  )}**)`;
+}
+
+function printSizeKByte(a, b) {
+  return printSize(a / 1024, b / 1024);
+}
+
+export async function findCommentId(github, context) {
+  let page = 0;
+  let response;
+  do {
+    response = await github.rest.issues.listComments({
+      issue_number: context.issue.number,
+      owner: context.repo.owner,
+      repo: context.repo.repo,
+      per_page: REQUESTED_COMMENTS_PER_PAGE,
+      page: page,
+      sort: 'updated',
+      direction: 'desc',
+    });
+    const found = response.data.find(
+      (comment) => !!comment.user && comment.body.startsWith(COMMENT_MARKER)
+    )?.id;
+    if (found) {
+      return found;
+    }
+    page++;
+  } while (response.data.length === REQUESTED_COMMENTS_PER_PAGE);
+}
+
+export async function run({ github, context, a, b }) {
+  const {
+    repo: { owner, repo },
+  } = context;
+
+  const table = [
+    ['file / KB (diff)', 'bundled', 'minified', 'gzipped'],
+    ['---', '---', '---', '---'],
+    ...Object.entries(b.size).map(([file, _b]) => {
+      const _a = {
+        bundled: 0,
+        minified: 0,
+        gzipped: 0,
+        ...(a.size[file] || {}),
+      };
+      return [
+        file,
+        printSizeKByte(_a.bundled, _b.bundled),
+        printSizeKByte(_a.minified, _b.minified),
+        printSizeKByte(_a.gzipped, _b.gzipped),
+      ];
+    }),
+  ];
+
+  const body = [
+    COMMENT_MARKER,
+    '**Build Stats**',
+    '',
+    ...table.map((row) => ['', ...row, ''].join(' | ')),
+    '',
+  ]
+    .join('\n')
+    .slice(0, MAX_COMMENT_CHARS);
+
+  const commentId = await findCommentId(github, context);
+
+  await (commentId
+    ? github.rest.issues.updateComment({
+        repo,
+        owner,
+        comment_id: commentId,
+        body,
+      })
+    : github.rest.issues.createComment({
+        repo,
+        owner,
+        issue_number: context.payload.pull_request.number,
+        body,
+      }));
+}
+
+export async function run_simple({ github, context, a, b }) {
+  const {
+    repo: { owner, repo },
+  } = context;
+
+  const table = [
+    ['file / KB (diff)', 'bundled', 'minified'],
+    ['---', '---', '---'],
+    ...Object.entries(b.size).map(([file, _b]) => {
+      const _a = {
+        bundled: 0,
+        minified: 0,
+        ...(a.size[file] || {}),
+      };
+      return [
+        file,
+        printSizeKByte(_a.bundled, _b.bundled),
+        printSizeKByte(_a.minified, _b.minified),
+      ];
+    }),
+  ];
+
+  const body = [
+    COMMENT_MARKER,
+    '**Build Stats**',
+    '',
+    ...table.map((row) => ['', ...row, ''].join(' | ')),
+    '',
+  ]
+    .join('\n')
+    .slice(0, MAX_COMMENT_CHARS);
+
+  const commentId = await findCommentId(github, context);
+
+  await (commentId
+    ? github.rest.issues.updateComment({
+        repo,
+        owner,
+        comment_id: commentId,
+        body,
+      })
+    : github.rest.issues.createComment({
+        repo,
+        owner,
+        issue_number: context.payload.pull_request.number,
+        body,
+      }));
+}

package/scripts/dirname.mjs

@@ -0,0 +1,14 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+export const __dirname = path.dirname(__filename);
+
+export const wd = path.resolve(__dirname, '..');
+export const dumpsPath = path.resolve(wd, 'cli_output');
+export const CLI_CACHE = path.resolve(dumpsPath, 'cli_cache.json');
+
+if (!fs.existsSync(dumpsPath)) {
+  fs.mkdirSync(dumpsPath);
+}

package/scripts/git.mjs

@@ -0,0 +1,36 @@
+import cp from 'child_process';
+import { wd } from './dirname.mjs';
+
+export function execGitCommand(cmd) {
+  return cp
+    .execSync(cmd, { cwd: wd })
+    .toString()
+    .replace(/\n/g, ',')
+    .split(',')
+    .map((value) => value.trim())
+    .filter((value) => value.length > 0);
+}
+
+export function getGitInfo(branchRef = '') {
+  const repo = execGitCommand('git config --get remote.origin.url')[0]
+    .replace('https://github.com/', '')
+    .replace('.git', '');
+  const branch = execGitCommand('git branch --show-current')[0];
+  const tag = execGitCommand('git describe --tags')[0];
+  const uncommittedChanges = execGitCommand('git status --porcelain').map(
+    (value) => {
+      const [type, path] = value.split(' ');
+      return { type, path };
+    }
+  );
+  const changes = execGitCommand(`git diff ${branchRef} --name-only`);
+  const userName = execGitCommand('git config user.name')[0];
+  return {
+    repo,
+    branch,
+    tag,
+    uncommittedChanges,
+    changes,
+    user: userName,
+  };
+}