@rancher/shell 0.1.0

package/utils/string.js

@@ -0,0 +1,286 @@
+export function camelToTitle(str) {
+  return dasherize((str || '')).split('-').map((str) => {
+    return ucFirst(str);
+  }).join(' ');
+}
+
+export function ucFirst(str) {
+  str = str || '';
+
+  return str.substr(0, 1).toUpperCase() + str.substr(1);
+}
+
+export function lcFirst(str) {
+  str = str || '';
+
+  return str.substr(0, 1).toLowerCase() + str.substr(1);
+}
+
+export function strPad(str, toLength, padChars = ' ', right = false) {
+  str = `${ str }`;
+
+  if (str.length >= toLength) {
+    return str;
+  }
+
+  const neededLen = toLength - str.length + 1;
+  const padStr = (new Array(neededLen)).join(padChars).substr(0, neededLen);
+
+  if (right) {
+    return str + padStr;
+  } else {
+    return padStr + str;
+  }
+}
+
+// Turn thing1 into thing00000001 so that the numbers sort numerically
+export function sortableNumericSuffix(str) {
+  str = str || '';
+  const match = str.match(/^(.*[^0-9])([0-9]+)$/);
+
+  if (match) {
+    return match[1] + strPad(match[2], 8, '0');
+  }
+
+  return str;
+}
+
+const entityMap = {
+  '&': '&',
+  '<': '&lt;',
+  '>': '&gt;',
+  '"': '&quot;',
+  "'": '&#39;',
+  '/': '&#x2F;'
+};
+
+export function escapeHtml(html) {
+  return String(html).replace(/[&<>"']/g, (s) => {
+    return entityMap[s];
+  });
+}
+
+export function escapeRegex(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+}
+
+export function random32(count) {
+  count = Math.max(0, count || 1);
+
+  const out = [];
+  let i;
+
+  if ( process.server ) {
+    const crypto = require('crypto');
+
+    for ( i = 0 ; i < count ; i++ ) {
+      out[i] = crypto.randomBytes(4).readUInt32BE(0, true);
+    }
+  } else if (window.crypto && window.crypto.getRandomValues) {
+    const tmp = new Uint32Array(count);
+
+    window.crypto.getRandomValues(tmp);
+    for (i = 0; i < tmp.length; i++) {
+      out[i] = tmp[i];
+    }
+  } else {
+    for (i = 0; i < count; i++) {
+      out[i] = Math.random() * 4294967296; // Math.pow(2,32);
+    }
+  }
+
+  if (count === 1) {
+    return out[0];
+  } else {
+    return out;
+  }
+}
+
+const alpha = 'abcdefghijklmnopqrstuvwxyz';
+const num = '0123456789';
+const sym = '!@#$%^&*()_+-=[]{};:,./<>?|';
+
+export const CHARSET = {
+  NUMERIC:     num,
+  NO_VOWELS:   'bcdfghjklmnpqrstvwxz2456789',
+  ALPHA:       alpha + alpha.toUpperCase(),
+  ALPHA_NUM:   alpha + alpha.toUpperCase() + num,
+  ALPHA_LOWER: alpha,
+  ALPHA_UPPER: alpha.toUpperCase(),
+  HEX:         `${ num }ABCDEF`,
+  PASSWORD:    alpha + alpha.toUpperCase() + num + alpha + alpha.toUpperCase() + num + sym,
+  // ^-- includes alpha / ALPHA / num twice to reduce the occurrence of symbols
+};
+
+export function randomStr(length = 16, chars = CHARSET.ALPHA_NUM) {
+  if (!chars || !chars.length) {
+    return null;
+  }
+
+  return random32(length).map((val) => {
+    return chars[val % chars.length];
+  }).join('');
+}
+
+export function formatPercent(value, maxPrecision = 2) {
+  if (value < 1 && maxPrecision >= 2) {
+    return `${ Math.round(value * 100) / 100 }%`;
+  } else if (value < 10 && maxPrecision >= 1) {
+    return `${ Math.round(value * 10) / 10 }%`;
+  } else {
+    return `${ Math.round(value) }%`;
+  }
+}
+
+export function pluralize(str) {
+  if ( str.match(/.*[^aeiou]y$/i) ) {
+    return `${ str.substr(0, str.length - 1) }ies`;
+  } else if ( str.endsWith('s') ) {
+    return `${ str }es`;
+  } else {
+    return `${ str }s`;
+  }
+}
+
+export function indent(lines, count = 2, token = ' ', afterRegex = null) {
+  if (typeof lines === 'string') {
+    lines = lines.split(/\n/);
+  } else {
+    lines = lines || [];
+  }
+
+  const padStr = (new Array(count + 1)).join(token);
+
+  const out = lines.map((line) => {
+    let prefix = '';
+    let suffix = line;
+
+    if (afterRegex) {
+      const match = line.match(afterRegex);
+
+      if (match) {
+        prefix = match[match.length - 1];
+        suffix = line.substr(match[0].length);
+      }
+    }
+
+    return `${ prefix }${ padStr }${ suffix }`;
+  });
+
+  const str = out.join('\n');
+
+  return str;
+}
+
+const decamelizeRegex = /([a-z\d])([A-Z])/g;
+
+export function decamelize(str) {
+  return str.replace(decamelizeRegex, '$1_$2').toLowerCase();
+}
+
+const dasherizeRegex = /[ _]/g;
+
+export function dasherize(str) {
+  return decamelize(str).replace(dasherizeRegex, '-');
+}
+
+export function asciiLike(str) {
+  str = str || '';
+
+  if ( str.match(/[^\r\n\t\x20-\x7F]/) ) {
+    return false;
+  }
+
+  return true;
+}
+
+export function coerceStringTypeToScalarType(val, type) {
+  if ( type === 'float' ) {
+    // Coerce strings to floats
+    val = parseFloat(val) || null; // NaN becomes null
+  } else if ( type === 'int' ) {
+    // Coerce strings to ints
+    val = parseInt(val, 10);
+
+    if ( isNaN(val) ) {
+      val = null;
+    }
+  } else if ( type === 'boolean') {
+    // Coerce strings to boolean
+    if (val.toLowerCase() === 'true') {
+      val = true;
+    } else if (val.toLowerCase() === 'false') {
+      val = false;
+    }
+  }
+
+  return val;
+}
+
+export function matchesSomeRegex(stringRaw, regexes = []) {
+  return regexes.some((regexRaw) => {
+    const string = stringRaw || '';
+    const regex = ensureRegex(regexRaw);
+
+    return string.match(regex);
+  });
+}
+
+export function ensureRegex(strOrRegex, exact = true) {
+  if ( typeof strOrRegex === 'string' ) {
+    if ( exact ) {
+      return new RegExp(`^${ escapeRegex(strOrRegex) }$`, 'i');
+    } else {
+      return new RegExp(`${ escapeRegex(strOrRegex) }`, 'i');
+    }
+  }
+
+  return strOrRegex;
+}
+
+export function nlToBr(value) {
+  return escapeHtml(value || '').replace(/(\r\n|\r|\n)/g, '<br/>\n');
+}
+
+const quotedMatch = /[^."']+|"([^"]*)"|'([^']*)'/g;
+
+export function splitObjectPath(path) {
+  if ( path.includes('"') || path.includes("'") ) {
+    // Path with quoted section
+    return path.match(quotedMatch).map(x => x.replace(/['"]/g, ''));
+  }
+
+  // Regular path
+  return path.split('.');
+}
+
+export function joinObjectPath(ary) {
+  let out = '';
+
+  for ( const p of ary ) {
+    if ( p.includes('.') ) {
+      out += `."${ p }"`;
+    } else {
+      out += `.${ p }`;
+    }
+  }
+
+  if ( out.startsWith('.') ) {
+    out = out.substr(1);
+  }
+
+  return out;
+}
+
+export function shortenedImage(image) {
+  return (image || '')
+    .replace(/^(index\.)?docker.io\/(library\/)?/, '')
+    .replace(/:latest$/, '')
+    .replace(/^(.*@sha256:)([0-9a-f]{8})[0-9a-f]+$/i, '$1$2…');
+}
+
+export function isIpv4(ip) {
+  const reg = /^((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$/;
+
+  return reg.test(ip);
+}

package/utils/time.js

@@ -0,0 +1,56 @@
+import day from 'dayjs';
+
+const FACTORS = [60, 60, 24];
+const LABELS = ['sec', 'min', 'hour', 'day'];
+
+// Diff two dates and return an object with values for presentation
+// If 't' is also passed, 'string' property is set on the return object with the diff formatted as a string
+// e.g. formats a date difference to return '1 day', '20 hours' etc
+export function diffFrom(value, from, t) {
+  const now = day();
+
+  from = from || now;
+  const diff = value.diff(now, 'seconds');
+
+  let absDiff = Math.abs(diff);
+
+  let next = 1;
+  let label = '?';
+
+  let i = 0;
+
+  while ( absDiff >= FACTORS[i] && i < FACTORS.length ) {
+    absDiff /= FACTORS[i];
+    next *= Math.floor(FACTORS[i] / 10);
+    i++;
+  }
+
+  if ( absDiff < 5 ) {
+    label = Math.floor(absDiff * 10) / 10;
+  } else {
+    label = Math.floor(absDiff);
+  }
+  const ret = {
+    diff,
+    absDiff,
+    label,
+    unitsKey: `unit.${ LABELS[i] }`,
+    units:    LABELS[i],
+    next,
+  };
+
+  if (!!t) {
+    ret.string = `${ ret.label } ${ t(ret.unitsKey, { count: ret.label }) }`;
+  }
+
+  return ret;
+}
+
+export function safeSetTimeout(timeout, callback, that) {
+  if (timeout <= 2147483647) {
+    // Max value setTimeout can take is max 32 bit int (about 24.9 days)
+    return setTimeout(() => {
+      callback.apply(that);
+    }, timeout);
+  }
+}

package/utils/type-helpers.ts

@@ -0,0 +1,9 @@
+
+export default {
+  memberOfObject: <V = string>(obj: { [key: string]: any}, key: string): V => {
+    return Object.entries(obj || {}).find(([k]) => k === key) as unknown as V;
+  },
+  memberOfComponent: <V = string>(obj: object | undefined, key: string): V => {
+    return (obj as any as { [key: string]: any})[key] as V;
+  },
+};

package/utils/units.js

@@ -0,0 +1,184 @@
+export const UNITS = ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
+export const FRACTIONAL = ['', 'm', 'u', 'n', 'p', 'f', 'a', 'z', 'y']; // milli micro nano pico femto
+
+export function formatSi(inValue, {
+  increment = 1000,
+  addSuffix = true,
+  addSuffixSpace = true,
+  suffix = '',
+  firstSuffix = null,
+  startingExponent = 0,
+  minExponent = 0,
+  maxExponent = 99,
+  maxPrecision = 2,
+  canRoundToZero = true,
+} = {}) {
+  let val = inValue;
+  let exp = startingExponent;
+  const divide = maxExponent >= 0;
+
+  // TODO More to think about re: min > max
+  if (divide) {
+    while ( ( val >= increment && exp + 1 < UNITS.length && exp < maxExponent ) || exp < minExponent ) {
+      val = val / increment;
+      exp++;
+    }
+  } else {
+    while ( ( val < increment && exp + 1 < FRACTIONAL.length && exp < (maxExponent * -1) ) || exp < (minExponent * -1) ) {
+      val = val * increment;
+      exp++;
+    }
+  }
+
+  let out = '';
+
+  if ( val < 10 && maxPrecision >= 1 ) {
+    out = `${ Math.round(val * (10 ** maxPrecision) ) / (10 ** maxPrecision) }`;
+  } else {
+    out = `${ Math.round(val) }`;
+  }
+
+  if (out === '0' && !canRoundToZero && inValue !== 0) {
+    const exponent = exponentNeeded(inValue, increment);
+
+    return formatSi(inValue, {
+      increment,
+      addSuffix,
+      suffix,
+      firstSuffix,
+      startingExponent,
+      minExponent:    exponent,
+      maxExponent:    exponent,
+      maxPrecision,
+      canRoundToZero: true,
+    });
+  }
+
+  if ( addSuffix ) {
+    if (addSuffixSpace) {
+      out += ` `;
+    }
+
+    if ( exp === 0 && firstSuffix !== null) {
+      out += `${ firstSuffix }`;
+    } else {
+      out += `${ divide ? UNITS[exp] : FRACTIONAL[exp] }${ suffix }` || '';
+    }
+  }
+
+  return out;
+}
+
+export function exponentNeeded(val, increment = 1000) {
+  let exp = 0;
+
+  while ( val >= increment ) {
+    val = val / increment;
+    exp++;
+  }
+
+  return exp;
+}
+
+export function parseSi(inValue, opt) {
+  opt = opt || {};
+  let increment = opt.increment;
+  const allowFractional = opt.allowFractional !== false;
+
+  if ( !inValue || typeof inValue !== 'string' || !inValue.length ) {
+    return NaN;
+  }
+
+  inValue = inValue.replace(/,/g, '');
+
+  // eslint-disable-next-line prefer-const
+  let [, valStr, unit, incStr] = inValue.match(/^([0-9.-]+)\s*([^0-9.-]?)([^0-9.-]?)/);
+  const val = parseFloat(valStr);
+
+  if ( !unit ) {
+    return val;
+  }
+
+  // micro "mu" symbol -> u
+  if ( unit.charCodeAt(0) === 181 ) {
+    unit = 'u';
+  }
+
+  const divide = FRACTIONAL.includes(unit);
+  const multiply = UNITS.includes(unit.toUpperCase());
+
+  if ( !increment ) {
+    // Automatically handle 1 KB = 1000B, 1 KiB = 1024B if no increment set
+    if ( (multiply || divide) && incStr === 'i' ) {
+      increment = 1024;
+    } else {
+      increment = 1000;
+    }
+  }
+
+  if ( divide && allowFractional ) {
+    const exp = FRACTIONAL.indexOf(unit);
+
+    return val / (increment ** exp);
+  }
+
+  if ( multiply ) {
+    const exp = UNITS.indexOf(unit.toUpperCase());
+
+    return val * (increment ** exp);
+  }
+
+  // Unrecognized unit character
+  return val;
+}
+
+export const MEMORY_PARSE_RULES = {
+  memory: {
+    format: {
+      addSuffix:        true,
+      firstSuffix:      'B',
+      increment:        1024,
+      maxExponent:      99,
+      maxPrecision:     2,
+      minExponent:      0,
+      startingExponent: 0,
+      suffix:           'iB',
+    }
+  }
+};
+
+export function createMemoryFormat(n) {
+  const exponent = exponentNeeded(n, MEMORY_PARSE_RULES.memory.format.increment);
+
+  return {
+    ...MEMORY_PARSE_RULES.memory.format,
+    maxExponent: exponent,
+    minExponent: exponent,
+  };
+}
+
+function createMemoryUnits(n) {
+  const exponent = exponentNeeded(n, MEMORY_PARSE_RULES.memory.format.increment);
+
+  return `${ UNITS[exponent] }${ MEMORY_PARSE_RULES.memory.format.suffix }`;
+}
+
+export function createMemoryValues(total, useful) {
+  const parsedTotal = parseSi((total || '0').toString());
+  const parsedUseful = parseSi((useful || '0').toString());
+  const format = createMemoryFormat(parsedTotal);
+  const formattedTotal = formatSi(parsedTotal, format);
+  const formattedUseful = formatSi(parsedUseful, format);
+
+  return {
+    total:  Number.parseFloat(formattedTotal),
+    useful: Number.parseFloat(formattedUseful),
+    units:  createMemoryUnits(parsedTotal)
+  };
+}
+
+export default {
+  exponentNeeded,
+  formatSi,
+  parseSi,
+};

package/utils/url.ts

@@ -0,0 +1,171 @@
+type UriField = 'source' | 'protocol' | 'authority' | 'userInfo' | 'user' | 'password' | 'host' | 'port' | 'relative' | 'path' | 'directory' | 'file' | 'queryStr' | 'anchor'
+type UriFields = {
+  [key in UriField]: string; // eslint-disable-line no-unused-vars
+}
+type QueryParams = {
+  [key: string]: string
+}
+
+interface ParsedUri extends UriFields {
+  query: QueryParams;
+}
+
+export function addParam(url: string, key: string, val: string | string[]): string {
+  let out = url + (url.includes('?') ? '&' : '?');
+
+  // val can be a string or an array of strings
+  if ( !Array.isArray(val) ) {
+    val = [val];
+  }
+  out += val.map((v) => {
+    if ( v === null ) {
+      return `${ encodeURIComponent(key) }`;
+    } else {
+      return `${ encodeURIComponent(key) }=${ encodeURIComponent(v) }`;
+    }
+  }).join('&');
+
+  return out;
+}
+
+export function addParams(url: string, params: QueryParams): string {
+  if ( params && typeof params === 'object' ) {
+    Object.keys(params).forEach((key) => {
+      url = addParam(url, key, params[key]);
+    });
+  }
+
+  return url;
+}
+
+export function removeParam(url: string, key: string): string {
+  const parsed = parse(url);
+
+  if ( parsed.query?.[key] ) {
+    delete parsed.query[key];
+  }
+
+  return stringify(parsed);
+}
+
+export function parseLinkHeader(str: string) {
+  const out: { [key: string]: string} = { };
+  const lines = (str || '').split(',');
+
+  for ( const line of lines ) {
+    const match = line.match(/^\s*<([^>]+)>\s*;\s*rel\s*="(.*)"/);
+
+    if ( match ) {
+      out[match[2].toLowerCase()] = match[1];
+    }
+  }
+
+  return out;
+}
+
+export function isMaybeSecure(port: number, proto: string): boolean {
+  const protocol = proto.toLowerCase();
+
+  return portMatch([port], [443, 8443], ['443']) || protocol === 'https';
+}
+
+export function portMatch(ports: number[], equals: number[], endsWith: string[]): boolean {
+  for (let i = 0; i < ports.length; i++) {
+    const port = ports[i];
+
+    if (equals.includes(port)) {
+      return true;
+    }
+
+    for (let j = 0; j < endsWith.length; j++) {
+      const suffix = `${ endsWith[j] }`;
+      const portStr = `${ port }`;
+
+      if (portStr !== suffix && portStr.endsWith(suffix)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+// parseUri 1.2.2
+// (c) Steven Levithan <stevenlevithan.com>
+// https://javascriptsource.com/parseuri/
+// MIT License
+export function parse(str: string): ParsedUri {
+  const o = parse.options;
+  const m = o.parser[o.strictMode ? 'strict' : 'loose'].exec(str);
+
+  if (!m) {
+    throw new Error(`Cannot parse as uri: ${ str }`);
+  }
+  const uri = {} as ParsedUri;
+  let i = 14;
+
+  while (i--) {
+    uri[o.key[i]] = m[i] || '';
+  }
+
+  uri.query = {};
+  uri.queryStr.replace(o.q.parser, (_, $1: string, $2: string): string => {
+    if ($1) {
+      uri[o.q.name][$1] = $2;
+    }
+
+    return '';
+  });
+
+  return uri;
+}
+
+parse.options = {
+  strictMode: false,
+  key:        ['source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'queryStr', 'anchor'],
+  q:          {
+    name:   'query',
+    parser: /(?:^|&)([^&=]*)=?([^&]*)/g
+  },
+  parser: {
+    strict: /^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,
+    loose:  /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/
+  }
+} as {
+  strictMode: boolean,
+  key: UriField[],
+  q: {
+    name: 'query',
+    parser: RegExp
+  },
+  parser: {
+    strict: RegExp,
+    loose: RegExp
+  }
+};
+
+export function stringify(uri: ParsedUri): string {
+  let out = `${ uri.protocol }://`;
+
+  if ( uri.user && uri.password ) {
+    out += `${ uri.user }:${ uri.password }@`;
+  } else if ( uri.user ) {
+    out += `${ uri.user }@`;
+  }
+
+  out += uri.host;
+
+  if ( uri.port ) {
+    out += `:${ uri.port }`;
+  }
+
+  out += uri.path || '/';
+
+  out = addParams(out, uri.query || {});
+
+  if ( uri.anchor ) {
+    out += `#${ uri.anchor }`;
+  }
+
+  return out;
+}

package/utils/validators/cidr.js

@@ -0,0 +1,5 @@
+const validCIDRregex = /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\/(3[0-2]|2[0-9]|1[0-9]|[0-9])$/;
+
+export function isValidCIDR(cidr) {
+  return !!cidr.match(validCIDRregex);
+}