piral-cli 1.0.0-pre.2217 → 1.0.0

package/src/common/version.test.ts

@@ -0,0 +1,233 @@
+import { satisfies, validate } from './version';
+
+describe('semver check module', () => {
+  it('specific publish version is valid', () => {
+    const result = validate('1.2.3');
+    expect(result).toBeTruthy();
+  });
+
+  it('shortened publish version is valid', () => {
+    const result = validate('1.2');
+    expect(result).toBeTruthy();
+  });
+
+  it('some hash is invalid', () => {
+    const result = validate('fabcde');
+    expect(result).toBeFalsy();
+  });
+
+  it('some longer hash is invalid', () => {
+    const result = validate('123fabdef0012');
+    expect(result).toBeFalsy();
+  });
+
+  it('major publish version is valid', () => {
+    const result = validate('1');
+    expect(result).toBeTruthy();
+  });
+
+  it('any publish version is valid', () => {
+    const result = validate('1.2.x');
+    expect(result).toBeTruthy();
+  });
+
+  it('specific preview version is valid', () => {
+    const result = validate('1.2.3-pre.123');
+    expect(result).toBeTruthy();
+  });
+
+  it('caret version is specifier valid', () => {
+    const result = validate('^1.2.3');
+    expect(result).toBeTruthy();
+  });
+
+  it('tilde version is specifier valid', () => {
+    const result = validate('~1.2.3');
+    expect(result).toBeTruthy();
+  });
+
+  it('greater version is specifier valid', () => {
+    const result = validate('>1.2.3');
+    expect(result).toBeTruthy();
+  });
+
+  it('greater equals version is specifier valid', () => {
+    const result = validate('>=1.2.3');
+    expect(result).toBeTruthy();
+  });
+
+  it('greater equals with x version is specifier valid', () => {
+    const result = validate('>=1.x');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies exact version match', () => {
+    const result = satisfies('1.2.3', '1.2.3');
+    expect(result).toBeTruthy();
+  });
+
+  it('does not satisfy exact version mismatch greater', () => {
+    const result = satisfies('1.2.3', '1.2.4');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy exact version mismatch smaller', () => {
+    const result = satisfies('1.2.3', '1.2.2');
+    expect(result).toBeFalsy();
+  });
+
+  it('satisfies constraint with caret patch', () => {
+    const result = satisfies('1.2.3', '^1.2.0');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies constraint with caret minor', () => {
+    const result = satisfies('1.3.0', '^1.2.0');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies constraint with caret exact', () => {
+    const result = satisfies('1.3.0', '^1.3.0');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies constraint with caret exact with dropped number', () => {
+    const result = satisfies('1.3.0', '^1.3');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies constraint with caret exact with dropped numbers', () => {
+    const result = satisfies('1', '^1');
+    expect(result).toBeTruthy();
+  });
+
+  it('does not satisfy constraint with caret major', () => {
+    const result = satisfies('2.0.0', '^1.2.0');
+    expect(result).toBeFalsy();
+  });
+
+  it('satisfies constraint with tilde patch', () => {
+    const result = satisfies('1.2.3', '~1.2.0');
+    expect(result).toBeTruthy();
+  });
+
+  it('does not satisfy constraint with tilde minor', () => {
+    const result = satisfies('1.3.0', '~1.2.0');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy constraint with tilde patch greater', () => {
+    const result = satisfies('1.3.0', '~1.3.2');
+    expect(result).toBeFalsy();
+  });
+
+  it('satisfies constraint with tilde patch lighter', () => {
+    const result = satisfies('1.3.3', '~1.3.2');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies constraint with x patch', () => {
+    const result = satisfies('1.2.3', '1.x.3');
+    expect(result).toBeTruthy();
+  });
+
+  it('does not satisfy constraint x minor', () => {
+    const result = satisfies('1.3.0', '1.2.x');
+    expect(result).toBeFalsy();
+  });
+
+  it('satsfies greater than matching', () => {
+    const result = satisfies('1.3.0', '>=1.2.0');
+    expect(result).toBeTruthy();
+  });
+
+  it('satsfies less than matching', () => {
+    const result = satisfies('1.3.0', '<=1.3.0');
+    expect(result).toBeTruthy();
+  });
+
+  it('does not satisfy only greater than non-matching', () => {
+    const result = satisfies('1.3.0', '>1.3.0');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy greater than non-matching', () => {
+    const result = satisfies('1.3.0', '>=1.3.1');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy less than non-matching', () => {
+    const result = satisfies('1.3.0', '<=1.2.0');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy less than non-matching', () => {
+    const result = satisfies('1.3.0', '<1.3.0');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy less than non-matching', () => {
+    const result = satisfies('1.3.0', '<=1.2.0');
+    expect(result).toBeFalsy();
+  });
+
+  it('satisfies exact version match with previews', () => {
+    const result = satisfies('1.2.3-pre.5', '1.2.3-pre.5');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies exact version match with dropped number', () => {
+    const result = satisfies('1.0', '1');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies exact version match with dropped numbers', () => {
+    const result = satisfies('1', '1.0.0');
+    expect(result).toBeTruthy();
+  });
+
+  it('does not satisfy exact version mismatch preview', () => {
+    const result = satisfies('1.2.4-pre.5', '1.2.4-pre.6');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy exact version mismatch preview version offered', () => {
+    const result = satisfies('1.2.4-beta', '1.2.4-beta.5');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy exact version mismatch preview version demanded', () => {
+    const result = satisfies('1.2.4-beta.5', '1.2.4-beta');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy exact version mismatch preview higher', () => {
+    const result = satisfies('1.2.4-gamma', '1.2.4-beta');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy exact version mismatch preview smaller', () => {
+    const result = satisfies('1.2.4-alpha', '1.2.4-beta');
+    expect(result).toBeFalsy();
+  });
+
+  it('does not satisfy exact and preview mismatch', () => {
+    const result = satisfies('1.2.4-pre.5', '1.2.4');
+    expect(result).toBeFalsy();
+  });
+
+  it('satisfies just an x', () => {
+    const result = satisfies('1.2.3', 'x');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies just a *', () => {
+    const result = satisfies('1.2.3', '*');
+    expect(result).toBeTruthy();
+  });
+
+  it('satisfies just a >=0', () => {
+    const result = satisfies('1.2.3', '>=0');
+    expect(result).toBeTruthy();
+  });
+});

package/src/common/version.ts

@@ -0,0 +1,142 @@
+const semver =
+  /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
+
+const acceptsAll = ['*', 'x', '>=0'];
+
+const operatorResMap: Record<string, [number, number?]> = {
+  '>': [1],
+  '>=': [0, 1],
+  '=': [0],
+  '<=': [-1, 0],
+  '<': [-1],
+};
+
+function indexOrEnd(str: string, q: string) {
+  return str.indexOf(q) === -1 ? str.length : str.indexOf(q);
+}
+
+function splitVersion(v: string) {
+  const c = v.replace(/^v/, '').replace(/\+.*$/, '');
+  const patchIndex = indexOrEnd(c, '-');
+  const arr = c.substring(0, patchIndex).split('.');
+  arr.push(c.substring(patchIndex + 1));
+  return arr;
+}
+
+function parseSegment(v: string) {
+  const n = parseInt(v, 10);
+  return isNaN(n) ? v : n;
+}
+
+function validateAndParse(v: string) {
+  const match = v.match(semver);
+  match.shift();
+  return match;
+}
+
+function compareStrings(a: string, b: string) {
+  const ap = parseSegment(a);
+  const bp = parseSegment(b);
+
+  if (ap > bp) {
+    return 1;
+  } else if (ap < bp) {
+    return -1;
+  } else {
+    return 0;
+  }
+}
+
+function compareSegments(a: [string, string], b: [string, string]) {
+  for (let i = 0; i < 2; i++) {
+    const r = compareStrings(a[i] || '0', b[i] || '0');
+
+    if (r !== 0) {
+      return r;
+    }
+  }
+
+  return 0;
+}
+
+function compareVersions(v1: string, v2: string) {
+  const s1 = splitVersion(v1);
+  const s2 = splitVersion(v2);
+  const len = Math.max(s1.length - 1, s2.length - 1);
+
+  for (let i = 0; i < len; i++) {
+    const n1 = parseInt(s1[i] || '0', 10);
+    const n2 = parseInt(s2[i] || '0', 10);
+
+    if (n1 > n2) {
+      return 1;
+    } else if (n2 > n1) {
+      return -1;
+    }
+  }
+
+  const sp1 = s1[s1.length - 1];
+  const sp2 = s2[s2.length - 1];
+
+  if (sp1 && sp2) {
+    const p1 = sp1.split('.').map(parseSegment);
+    const p2 = sp2.split('.').map(parseSegment);
+    const len = Math.max(p1.length, p2.length);
+
+    for (let i = 0; i < len; i++) {
+      if (p1[i] === undefined || (typeof p2[i] === 'string' && typeof p1[i] === 'number')) {
+        return -1;
+      } else if (p2[i] === undefined || (typeof p1[i] === 'string' && typeof p2[i] === 'number')) {
+        return 1;
+      } else if (p1[i] > p2[i]) {
+        return 1;
+      } else if (p2[i] > p1[i]) {
+        return -1;
+      }
+    }
+  } else if (sp1 || sp2) {
+    return sp1 ? -1 : 1;
+  }
+
+  return 0;
+}
+
+function compare(v1: string, v2: string, operator: string) {
+  // since result of compareVersions can only be -1 or 0 or 1
+  // a simple map can be used to replace switch
+  const res = compareVersions(v1, v2);
+  return operatorResMap[operator].indexOf(res) > -1;
+}
+
+export function validate(version: string) {
+  return acceptsAll.includes(version) || semver.test(version);
+}
+
+export function satisfies(v: string, r: string) {
+  if (!acceptsAll.includes(r)) {
+    // if no range operator then "="
+    const match = r.match(/^([<>=~^]+)/);
+    const op = match ? match[1] : '=';
+
+    // if gt/lt/eq then operator compare
+    if (op !== '^' && op !== '~') {
+      return compare(v, r, op);
+    }
+
+    // else range of either "~" or "^" is assumed
+    const [v1, v2, v3] = validateAndParse(v);
+    const [m1, m2, m3] = validateAndParse(r);
+
+    if (compareStrings(v1, m1) !== 0) {
+      return false;
+    } else if (op === '^') {
+      return compareSegments([v2, v3], [m2, m3]) >= 0;
+    } else if (compareStrings(v2, m2) !== 0) {
+      return false;
+    }
+
+    return compareStrings(v3, m3) >= 0;
+  }
+
+  return true;
+}

package/src/common/watcher.ts

@@ -0,0 +1,89 @@
+import { watch, existsSync } from 'fs';
+
+export interface WatcherRef<T> {
+  end: Promise<void>;
+  data: T;
+  onTrigger(cb: () => void): void;
+}
+
+export interface WatcherContext {
+  onClean(dispose: () => void): void;
+  watch(file: string): void;
+  dependOn<T>(ref: WatcherRef<T>): void;
+  close(): void;
+  status: 'initial' | 'reoccuring';
+}
+
+export function watcherTask<T = void>(cb: (watcherContext: WatcherContext) => Promise<T>) {
+  let running = Promise.resolve();
+  let pending = false;
+  let notify = () => {};
+
+  const disposers: Array<() => void> = [];
+  const triggers: Array<() => void> = [];
+  const end = new Promise<void>(resolve => {
+    notify = resolve;
+  });
+  const ref: WatcherRef<T> = {
+    data: undefined,
+    onTrigger(cb) {
+      triggers.push(cb);
+    },
+    end,
+  };
+
+  const reRun = async () => {
+    if (!pending) {
+      pending = true;
+      await running;
+      disposers.splice(0, disposers.length).forEach((dispose) => {
+        dispose();
+      });
+      pending = false;
+      context.status = 'reoccuring';
+      await run();
+
+      triggers.splice(0, triggers.length).forEach((trigger) => {
+        trigger();
+      });
+    }
+  };
+
+  const context: WatcherContext = {
+    onClean(dispose) {
+      disposers.push(dispose);
+    },
+    watch(file) {
+      if (existsSync(file)) {
+        const watcher = watch(
+          file,
+          {
+            persistent: false,
+          },
+          reRun,
+        );
+        disposers.push(() => watcher.close());
+      }
+    },
+    dependOn(anotherRef) {
+      anotherRef.onTrigger(reRun);
+    },
+    close() {
+      cb = () => Promise.resolve(undefined);
+      reRun().then(notify);
+    },
+    status: 'initial',
+  };
+
+  const run = async () => {
+    running = cb(context).then((data) => {
+      ref.data = data;
+    });
+    await running;
+    return ref;
+  };
+
+  return new Promise<WatcherRef<T>>((resolve, reject) => {
+    run().then(resolve, reject);
+  });
+}

package/src/external/index.test.ts

@@ -1,4 +1,4 @@
-import * as externals from './index';
+import * as externals from '../external';
 
 describe('Externals module', () => {
   it('exports the FormData class', () => {
@@ -27,7 +27,7 @@ describe('Externals module', () => {
   });
 
   it('exports the logger module', () => {
-    const logger = externals.logger;
+    const logger = externals.ora;
     expect(logger).not.toBeUndefined();
   });
 

package/src/external/index.ts

@@ -1,6 +1,5 @@
-import logger = require('@parcel/logger');
-import stripAnsi = require('strip-ansi');
 import inquirer = require('inquirer');
+import jju = require('jju');
 import glob = require('glob');
 import tar = require('tar');
 import FormData = require('form-data');
@@ -9,5 +8,10 @@ import axios = require('axios');
 import mime = require('mime');
 import getPort = require('get-port');
 import open = require('open');
+import chalk = require('chalk');
 
-export { logger, inquirer, glob, tar, FormData, rc, axios, mime, stripAnsi, getPort, open };
+import isInteractive from 'is-interactive';
+import ora from 'ora';
+import { getModulePath } from './resolve';
+
+export { chalk, inquirer, isInteractive, ora, glob, tar, FormData, rc, axios, mime, getPort, open, jju, getModulePath };

package/src/external/resolve.ts

@@ -0,0 +1,29 @@
+import * as fs from 'graceful-fs';
+import { ResolverFactory, CachedInputFileSystem } from 'enhanced-resolve';
+
+const nodeFileSystem = new CachedInputFileSystem(fs, 100);
+
+const nodeContext = {
+  environments: ['node+es3+es5+process+native'],
+};
+
+const enhancedResolve = ResolverFactory.createResolver({
+  aliasFields: ['browser'],
+  conditionNames: ['import', 'module', 'webpack', 'development', 'browser'],
+  extensions: ['.js', '.jsx', '.mjs', '.ts', '.tsx', '.json'],
+  exportsFields: ['exports'],
+  importsFields: ['imports'],
+  mainFields: ['browser', 'module', 'main'],
+  useSyncFileSystemCalls: true,
+  fileSystem: nodeFileSystem,
+});
+
+export function getModulePath(root: string, moduleName: string) {
+  const res = enhancedResolve.resolveSync(nodeContext, root, moduleName);
+
+  if (!res) {
+    throw new Error(`Could not find module "${moduleName}".`);
+  }
+
+  return res;
+}

package/src/helpers.test.ts

@@ -1,5 +1,5 @@
-import { keyOfForceOverwrite, keyOfPiletLanguage, valueOfForceOverwrite, valueOfPiletLanguage } from './helpers';
-import { ForceOverwrite, SourceLanguage } from './common/enums';
+import { keyOfForceOverwrite, valueOfForceOverwrite } from './helpers';
+import { ForceOverwrite } from './common/enums';
 
 describe('Piral CLI Command Helpers Module', () => {
   it('correct value of keyOfForceOverwrite results in same key', () => {
@@ -12,16 +12,6 @@ describe('Piral CLI Command Helpers Module', () => {
     expect(result).toBe('no');
   });
 
-  it('correct value of keyOfPiletLanguage results in same key', () => {
-    const result = keyOfPiletLanguage(SourceLanguage.ts);
-    expect(result).toBe('ts');
-  });
-
-  it('incorrect value of keyOfPiletLanguage results in key for TS', () => {
-    const result = keyOfPiletLanguage(5);
-    expect(result).toBe('ts');
-  });
-
   it('correct key of valueOfForceOverwrite results in same value', () => {
     const result = valueOfForceOverwrite('prompt');
     expect(result).toBe(ForceOverwrite.prompt);
@@ -31,14 +21,4 @@ describe('Piral CLI Command Helpers Module', () => {
     const result = valueOfForceOverwrite('foo');
     expect(result).toBe(ForceOverwrite.no);
   });
-
-  it('correct key of valueOfPiletLanguage results in same value', () => {
-    const result = valueOfPiletLanguage('ts');
-    expect(result).toBe(SourceLanguage.ts);
-  });
-
-  it('incorrect key of valueOfPiletLanguage results in value for TS', () => {
-    const result = valueOfPiletLanguage('foo');
-    expect(result).toBe(SourceLanguage.ts);
-  });
 });

package/src/helpers.ts

@@ -1,14 +1,27 @@
-import { ForceOverwrite, SourceLanguage } from './common/enums';
-import { Framework, NpmClientType, PiletSchemaVersion, PiletPublishSource, PiralBuildType } from './types';
-
-export const schemaKeys: Array<PiletSchemaVersion> = ['v0', 'v1', 'none'];
+import { ForceOverwrite } from './common/enums';
+import { bundlerNames, frameworkLibs } from './common/constants';
+import type {
+  Framework,
+  NpmClientType,
+  PiletSchemaVersion,
+  PiletPublishSource,
+  PiralBuildType,
+  PiletBuildType,
+  PiletPublishScheme,
+  SourceLanguage,
+} from './types';
+
+export const schemaKeys: Array<PiletSchemaVersion> = ['v0', 'v1', 'v2', 'none'];
+export const publishModeKeys: Array<PiletPublishScheme> = ['none', 'basic', 'bearer', 'digest'];
 export const fromKeys: Array<PiletPublishSource> = ['local', 'remote', 'npm'];
-export const buildTypeKeys: Array<PiralBuildType> = ['all', 'release', 'emulator', 'emulator-sources'];
-export const clientTypeKeys: Array<NpmClientType> = ['npm', 'pnpm', 'yarn'];
-export const bundlerKeys: Array<string> = ['none', 'parcel', 'webpack', 'webpack5'];
+export const piralBuildTypeKeys: Array<PiralBuildType> = ['all', 'release', 'emulator', 'emulator-sources'];
+export const piletBuildTypeKeys: Array<PiletBuildType> = ['default', 'standalone', 'manifest'];
+export const clientTypeKeys: Array<NpmClientType> = ['npm', 'pnpm', 'pnp', 'yarn', 'lerna', 'rush'];
+export const sourceLanguageKeys: Array<SourceLanguage> = ['ts', 'js'];
+export const bundlerKeys: Array<string> = ['none', ...bundlerNames];
 export const availableBundlers: Array<string> = [];
 export const availableReleaseProviders: Array<string> = [];
-export const frameworkKeys: Array<Framework> = ['piral', 'piral-core', 'piral-base'];
+export const frameworkKeys: Array<Framework> = [...frameworkLibs];
 export const forceOverwriteKeys = Object.keys(ForceOverwrite).filter((m) => typeof ForceOverwrite[m] === 'number');
 
 export function valueOfForceOverwrite(key: string): ForceOverwrite {
@@ -30,25 +43,3 @@ export function keyOfForceOverwrite(value: ForceOverwrite) {
 
   return forceOverwriteKeys[0];
 }
-
-export const piletLanguageKeys = Object.keys(SourceLanguage).filter((m) => typeof SourceLanguage[m] === 'number');
-
-export function valueOfPiletLanguage(key: string): SourceLanguage {
-  for (const piletLanguageKey of piletLanguageKeys) {
-    if (piletLanguageKey === key) {
-      return SourceLanguage[piletLanguageKey];
-    }
-  }
-
-  return SourceLanguage.ts;
-}
-
-export function keyOfPiletLanguage(value: SourceLanguage) {
-  for (const piletLanguageKey of piletLanguageKeys) {
-    if (SourceLanguage[piletLanguageKey] === value) {
-      return piletLanguageKey;
-    }
-  }
-
-  return piletLanguageKeys[0];
-}

package/src/injectors/{pilet.test.ts → pilet-injector.test.ts}

@@ -1,19 +1,22 @@
 import { EventEmitter } from 'events';
 import { KrasRequest } from 'kras';
-import PiletInjector from './pilet';
+import PiletInjector from './pilet-injector';
 
 const optionsMock = {
   pilets: [],
+  publicUrl: '/',
   api: '',
   app: '',
   active: true,
+  meta: '',
+  headers: {},
 };
 
 const configMock: any = {
   port: 1234,
 };
 
-describe('Piral-CLI piral injector', () => {
+describe('Piral-CLI pilet injector', () => {
   it('PiletInjector is active when configured', () => {
     const core = new EventEmitter();
     const injector = new PiletInjector(optionsMock, configMock, core);
@@ -30,7 +33,7 @@ describe('Piral-CLI piral injector', () => {
     injector.name;
     injector.getOptions();
     //injector.getMetaOf(0);
-    injector.getMeta();
+    injector.getIndexMeta('http://localhost:9000');
 
     // Assert
     expect(injector.active).toBeFalsy();
@@ -73,7 +76,7 @@ describe('Piral-CLI piral injector', () => {
     const injector = new PiletInjector(optionsMock, configMock, core);
 
     // Act
-    const res = await injector.sendResponse('some/nice/invalid/path', 'localhost:1234');
+    const res = await injector.sendResponse('some/nice/invalid/path', 'localhost:1234', 'http://localhost:9000');
 
     // Assert
     expect(res).toBeUndefined();
@@ -85,6 +88,9 @@ describe('Piral-CLI piral injector', () => {
       pilets: [],
       api: 'http://someFakeApi:1234',
       app: '',
+      publicUrl: '/',
+      meta: '',
+      headers: {},
       active: true,
     };
 
@@ -112,6 +118,9 @@ describe('Piral-CLI piral injector', () => {
       pilets: [],
       api: 'http://someFakeApi:1234',
       app: '',
+      publicUrl: '/',
+      meta: '',
+      headers: {},
       active: true,
     };
     const core = new EventEmitter();