elm-pages 3.0.0-beta.23 → 3.0.0-beta.25

package/generator/dead-code-review/node_modules/elm-test/lib/DependencyProvider.js

@@ -1,343 +0,0 @@
-// @flow
-
-const fs = require('fs');
-const path = require('path');
-const wasm = require('elm-solve-deps-wasm');
-const ElmHome = require('./ElmHome.js');
-const SyncGet = require('./SyncGet.js');
-const collator = new Intl.Collator('en', { numeric: true }); // for sorting SemVer strings
-
-// Initialization work done only once.
-wasm.init();
-const syncGetWorker /*: {| get: (string) => string, shutDown: () => void |} */ =
-  SyncGet.startWorker();
-
-// Cache of existing versions according to the package website.
-class OnlineVersionsCache {
-  map /*: Map<string, Array<string>> */ = new Map();
-
-  update() {
-    const pubgrubHome = path.join(ElmHome.elmHome(), 'pubgrub');
-    fs.mkdirSync(pubgrubHome, { recursive: true });
-    const cachePath = path.join(pubgrubHome, 'versions_cache.json');
-    const remotePackagesUrl = 'https://package.elm-lang.org/all-packages';
-    if (this.map.size === 0) {
-      let cacheFile;
-      try {
-        // Read from disk existing versions which are already cached.
-        cacheFile = fs.readFileSync(cachePath, 'utf8');
-      } catch (_) {
-        // The cache file does not exist so let's reset it.
-        this.map = onlineVersionsFromScratch(cachePath, remotePackagesUrl);
-        return;
-      }
-      try {
-        this.map = parseOnlineVersions(JSON.parse(cacheFile));
-      } catch (error) {
-        throw new Error(
-          `Failed to parse the cache file ${cachePath}.\n${error.message}`
-        );
-      }
-    }
-    this.updateWithRequestSince(cachePath, remotePackagesUrl);
-  }
-
-  // Update the cache with a request to the package server.
-  updateWithRequestSince(
-    cachePath /*: string */,
-    remotePackagesUrl /*: string */
-  ) /*: void */ {
-    // Count existing versions.
-    let versionsCount = 0;
-    for (const versions of this.map.values()) {
-      versionsCount += versions.length;
-    }
-
-    // Complete cache with a remote call to the package server.
-    const remoteUrl = remotePackagesUrl + '/since/' + (versionsCount - 1); // -1 to check if no package was deleted.
-    const newVersions = JSON.parse(syncGetWorker.get(remoteUrl));
-    if (newVersions.length === 0) {
-      // Reload from scratch since it means at least one package was deleted from the registry.
-      this.map = onlineVersionsFromScratch(cachePath, remotePackagesUrl);
-      return;
-    }
-    // Check that the last package in the list was already in cache
-    // since the list returned by the package server is sorted newest first.
-    const { pkg, version } = splitPkgVersion(newVersions.pop());
-    const cachePkgVersions = this.map.get(pkg);
-    if (
-      cachePkgVersions !== undefined &&
-      cachePkgVersions[cachePkgVersions.length - 1] === version
-    ) {
-      // Insert (in reverse) newVersions into onlineVersionsCache map.
-      for (const pkgVersion of newVersions.reverse()) {
-        const { pkg, version } = splitPkgVersion(pkgVersion);
-        const versionsOfPkg = this.map.get(pkg);
-        if (versionsOfPkg === undefined) {
-          this.map.set(pkg, [version]);
-        } else {
-          versionsOfPkg.push(version);
-        }
-      }
-      // Save the updated onlineVersionsCache to disk.
-      const onlineVersions = Object.fromEntries(this.map.entries());
-      fs.writeFileSync(cachePath, JSON.stringify(onlineVersions));
-    } else {
-      // There was a problem and a package got deleted from the server.
-      this.map = onlineVersionsFromScratch(cachePath, remotePackagesUrl);
-    }
-  }
-
-  getVersions(pkg /*: string */) /*: Array<string> */ {
-    const versions = this.map.get(pkg);
-    return versions === undefined ? [] : versions;
-  }
-}
-
-class OnlineAvailableVersionLister {
-  // Memoization cache to avoid doing the same work twice in list.
-  memoCache /*: Map<string, Array<string>> */ = new Map();
-  onlineCache /*: OnlineVersionsCache */;
-
-  constructor(onlineCache /*: OnlineVersionsCache */) {
-    onlineCache.update();
-    this.onlineCache = onlineCache;
-  }
-
-  list(pkg /*: string */) /*: Array<string> */ {
-    const memoVersions = this.memoCache.get(pkg);
-    if (memoVersions !== undefined) {
-      return memoVersions;
-    }
-    const offlineVersions = readVersionsInElmHomeAndSort(pkg);
-    const allVersionsSet = new Set(this.onlineCache.getVersions(pkg));
-    // Combine local and online versions.
-    for (const version of offlineVersions) {
-      allVersionsSet.add(version);
-    }
-    const allVersions = [...allVersionsSet].sort(flippedSemverCompare);
-    this.memoCache.set(pkg, allVersions);
-    return allVersions;
-  }
-}
-
-class OfflineAvailableVersionLister {
-  // Memoization cache to avoid doing the same work twice in list.
-  cache /*: Map<string, Array<string>> */ = new Map();
-
-  list(pkg /*: string */) /*: Array<string> */ {
-    const memoVersions = this.cache.get(pkg);
-    if (memoVersions !== undefined) {
-      return memoVersions;
-    }
-
-    const offlineVersions = readVersionsInElmHomeAndSort(pkg);
-
-    this.cache.set(pkg, offlineVersions);
-    return offlineVersions;
-  }
-}
-
-function readVersionsInElmHomeAndSort(pkg /*: string */) /*: Array<string> */ {
-  const pkgPath = ElmHome.packagePath(pkg);
-  let offlineVersions;
-  try {
-    offlineVersions = fs.readdirSync(pkgPath);
-  } catch (_) {
-    // The directory doesn't exist or we don't have permissions.
-    // It's fine to catch all cases and return an empty list.
-    offlineVersions = [];
-  }
-
-  return offlineVersions.sort(flippedSemverCompare);
-}
-
-class DependencyProvider {
-  cache /*: OnlineVersionsCache */ = new OnlineVersionsCache();
-
-  // Solve dependencies completely offline, without any http request.
-  solveOffline(
-    elmJson /*: string */,
-    useTest /*: boolean */,
-    extra /*: { [string]: string } */
-  ) /*: string */ {
-    const lister = new OfflineAvailableVersionLister();
-    try {
-      return wasm.solve_deps(
-        elmJson,
-        useTest,
-        extra,
-        fetchElmJsonOffline,
-        (pkg) => lister.list(pkg)
-      );
-    } catch (errorMessage) {
-      throw new Error(errorMessage);
-    }
-  }
-
-  // Solve dependencies with http requests when required.
-  solveOnline(
-    elmJson /*: string */,
-    useTest /*: boolean */,
-    extra /*: { [string]: string } */
-  ) /*: string */ {
-    const lister = new OnlineAvailableVersionLister(this.cache);
-    try {
-      return wasm.solve_deps(
-        elmJson,
-        useTest,
-        extra,
-        fetchElmJsonOnline,
-        (pkg) => lister.list(pkg)
-      );
-    } catch (errorMessage) {
-      throw new Error(errorMessage);
-    }
-  }
-}
-
-function fetchElmJsonOnline(
-  pkg /*: string */,
-  version /*: string */
-) /*: string */ {
-  try {
-    return fetchElmJsonOffline(pkg, version);
-  } catch (_) {
-    // `fetchElmJsonOffline` can only fail in ways that are either expected
-    // (such as file does not exist or no permissions)
-    // or because there was an error parsing `pkg` and `version`.
-    // In such case, this will throw again with `cacheElmJsonPath()` so it's fine.
-    const remoteUrl = remoteElmJsonUrl(pkg, version);
-    const elmJson = syncGetWorker.get(remoteUrl);
-    const cachePath = cacheElmJsonPath(pkg, version);
-    const parentDir = path.dirname(cachePath);
-    fs.mkdirSync(parentDir, { recursive: true });
-    fs.writeFileSync(cachePath, elmJson);
-    return elmJson;
-  }
-}
-
-function fetchElmJsonOffline(
-  pkg /*: string */,
-  version /*: string */
-) /*: string */ {
-  try {
-    return fs.readFileSync(homeElmJsonPath(pkg, version), 'utf8');
-  } catch (_) {
-    // The read can only fail if the elm.json file does not exist
-    // or if we don't have the permissions to read it so it's fine to catch all.
-    // Otherwise, it means that `homeElmJsonPath()` failed while processing `pkg` and `version`.
-    // In such case, again, it's fine to catch all since the next call to `cacheElmJsonPath()`
-    // will fail the same anyway.
-    return fs.readFileSync(cacheElmJsonPath(pkg, version), 'utf8');
-  }
-}
-
-// Reset the cache of existing versions from scratch
-// with a request to the package server.
-function onlineVersionsFromScratch(
-  cachePath /*: string */,
-  remotePackagesUrl /*: string */
-) /*: Map<string, Array<string>> */ {
-  const onlineVersionsJson = syncGetWorker.get(remotePackagesUrl);
-  fs.writeFileSync(cachePath, onlineVersionsJson);
-  const onlineVersions = JSON.parse(onlineVersionsJson);
-  try {
-    return parseOnlineVersions(onlineVersions);
-  } catch (error) {
-    throw new Error(
-      `Failed to parse the response from the request to ${remotePackagesUrl}.\n${error.message}`
-    );
-  }
-}
-
-// Helper functions ##################################################
-
-/* Compares two versions so that newer versions appear first when sorting with this function. */
-function flippedSemverCompare(a /*: string */, b /*: string */) /*: number */ {
-  return collator.compare(b, a);
-}
-
-function parseOnlineVersions(
-  json /*: mixed */
-) /*: Map<string, Array<string>> */ {
-  if (typeof json !== 'object' || json === null || Array.isArray(json)) {
-    throw new Error(
-      `Expected an object, but got: ${
-        json === null ? 'null' : Array.isArray(json) ? 'Array' : typeof json
-      }`
-    );
-  }
-
-  const result = new Map();
-
-  for (const [key, value] of Object.entries(json)) {
-    result.set(key, parseVersions(key, value));
-  }
-
-  return result;
-}
-
-function parseVersions(
-  key /*: string */,
-  json /*: mixed */
-) /*: Array<string> */ {
-  if (!Array.isArray(json)) {
-    throw new Error(
-      `Expected ${JSON.stringify(key)} to be an array, but got: ${typeof json}`
-    );
-  }
-
-  for (const [index, item] of json.entries()) {
-    if (typeof item !== 'string') {
-      throw new Error(
-        `Expected${JSON.stringify(
-          key
-        )}->${index} to be a string, but got: ${typeof item}`
-      );
-    }
-  }
-
-  // $FlowFixMe[incompatible-return]: We dynamically checked that `json` is an `Array<string>`.
-  return json;
-}
-
-function remoteElmJsonUrl(
-  pkg /*: string */,
-  version /*: string */
-) /*: string */ {
-  return `https://package.elm-lang.org/packages/${pkg}/${version}/elm.json`;
-}
-
-function cacheElmJsonPath(
-  pkg /*: string */,
-  version /*: string */
-) /*: string */ {
-  const parts = ElmHome.splitAuthorPkg(pkg);
-  return path.join(
-    ElmHome.elmHome(),
-    'pubgrub',
-    'elm_json_cache',
-    parts.author,
-    parts.pkg,
-    version,
-    'elm.json'
-  );
-}
-
-function homeElmJsonPath(
-  pkg /*: string */,
-  version /*: string */
-) /*: string */ {
-  return path.join(ElmHome.packagePath(pkg), version, 'elm.json');
-}
-
-function splitPkgVersion(str /*: string */) /*: {
-  pkg: string,
-  version: string,
-} */ {
-  const parts = str.split('@');
-  return { pkg: parts[0], version: parts[1] };
-}
-
-module.exports = DependencyProvider;

package/generator/dead-code-review/node_modules/elm-test/lib/ElmCompiler.js

@@ -1,109 +0,0 @@
-// @flow
-
-'use strict';
-
-var spawn = require('cross-spawn');
-
-var defaultOptions = {
-  spawn: spawn,
-  cwd: undefined,
-  pathToElm: 'elm',
-  output: undefined,
-  report: undefined,
-  processOpts: undefined,
-};
-
-// Converts an object of key/value pairs to an array of arguments suitable
-// to be passed to child_process.spawn for elm-make.
-function compilerArgsFromOptions(options) {
-  var args = [];
-
-  if (options.output != null) {
-    args.push('--output', options.output);
-  }
-
-  if (options.report != null) {
-    args.push('--report', options.report);
-  }
-
-  return args;
-}
-
-function runCompiler(sources, options) {
-  var pathToElm = options.pathToElm;
-  var processArgs = ['make'].concat(sources, compilerArgsFromOptions(options));
-
-  var processOpts = Object.assign(
-    {},
-    {
-      env: Object.assign({ LANG: 'en_US.UTF-8' }, process.env),
-      stdio: 'inherit',
-      cwd: options.cwd,
-    },
-    options.processOpts
-  );
-
-  return options.spawn(pathToElm, processArgs, processOpts);
-}
-
-function compilerErrorToString(err, pathToElm) {
-  if (typeof err === 'object' && typeof err.code === 'string') {
-    switch (err.code) {
-      case 'ENOENT':
-        return (
-          'Could not find Elm compiler "' + pathToElm + '". Is it installed?'
-        );
-
-      case 'EACCES':
-        return (
-          'Elm compiler "' +
-          pathToElm +
-          '" did not have permission to run. Do you need to give it executable permissions?'
-        );
-
-      default:
-        return (
-          'Error attempting to run Elm compiler "' + pathToElm + '":\n' + err
-        );
-    }
-  } else if (typeof err === 'object' && typeof err.message === 'string') {
-    return JSON.stringify(err.message);
-  } else {
-    return (
-      'Exception thrown when attempting to run Elm compiler ' +
-      JSON.stringify(pathToElm)
-    );
-  }
-}
-
-function compile(
-  sources /*: Array<string> */,
-  options /*: {|
-    spawn?: (
-      string,
-      Array<string>,
-      child_process$spawnOpts
-    ) => child_process$ChildProcess,
-    cwd?: string,
-    pathToElm?: string,
-    output?: string,
-    report?: 'json',
-    processOpts?: child_process$spawnOpts,
-  |} */
-) /*: child_process$ChildProcess */ {
-  var optionsWithDefaults = Object.assign({}, defaultOptions, options);
-  try {
-    return runCompiler(sources, optionsWithDefaults).on(
-      'error',
-      function (err) {
-        throw err;
-      }
-    );
-  } catch (err) {
-    throw new Error(compilerErrorToString(err, optionsWithDefaults.pathToElm));
-  }
-}
-
-module.exports = {
-  compile: compile,
-};

package/generator/dead-code-review/node_modules/elm-test/lib/ElmHome.js

@@ -1,47 +0,0 @@
-// @flow
-
-const path = require('path');
-const os = require('os');
-
-function elmHome() /*: string */ {
-  const elmHomeEnv = process.env['ELM_HOME'];
-  return elmHomeEnv === undefined ? defaultElmHome() : elmHomeEnv;
-}
-
-function defaultElmHome() /*: string */ {
-  return process.platform === 'win32'
-    ? defaultWindowsElmHome()
-    : defaultUnixElmHome();
-}
-
-function defaultUnixElmHome() /*: string */ {
-  return path.join(os.homedir(), '.elm');
-}
-
-function defaultWindowsElmHome() /*: string */ {
-  const appData = process.env.APPDATA;
-  const dir =
-    appData === undefined
-      ? path.join(os.homedir(), 'AppData', 'Roaming')
-      : appData;
-  return path.join(dir, 'elm');
-}
-
-function packagePath(pkg /*: string */) /*: string */ {
-  const parts = splitAuthorPkg(pkg);
-  return path.join(elmHome(), '0.19.1', 'packages', parts.author, parts.pkg);
-}
-
-function splitAuthorPkg(pkgIdentifier /*: string */) /*: {
-  author: string,
-  pkg: string,
-} */ {
-  const parts = pkgIdentifier.split('/');
-  return { author: parts[0], pkg: parts[1] };
-}
-
-module.exports = {
-  elmHome,
-  packagePath,
-  splitAuthorPkg,
-};

package/generator/dead-code-review/node_modules/elm-test/lib/ElmJson.js

@@ -1,194 +0,0 @@
-// @flow
-
-const fs = require('fs');
-const path = require('path');
-
-// Poor man’s type alias. We can’t use /*:: type Dependencies = ... */ because of:
-// https://github.com/prettier/prettier/issues/2597
-const Dependencies /*: { [string]: string } */ = {};
-
-const DirectAndIndirectDependencies /*: {
-  direct: typeof Dependencies,
-  indirect: typeof Dependencies,
-} */ = { direct: {}, indirect: {} };
-
-const ElmJson /*:
-  | {
-      type: 'application',
-      'source-directories': Array<string>,
-      dependencies: typeof DirectAndIndirectDependencies,
-      'test-dependencies': typeof DirectAndIndirectDependencies,
-      [string]: mixed,
-    }
-  | {
-      type: 'package',
-      dependencies: typeof Dependencies,
-      'test-dependencies': typeof Dependencies,
-      [string]: mixed,
-    } */ = {
-  type: 'package',
-  dependencies: Dependencies,
-  'test-dependencies': Dependencies,
-};
-
-function getPath(dir /*: string */) /*: string */ {
-  return path.join(dir, 'elm.json');
-}
-
-function write(dir /*: string */, elmJson /*: typeof ElmJson */) /*: void */ {
-  const elmJsonPath = getPath(dir);
-
-  try {
-    fs.writeFileSync(elmJsonPath, JSON.stringify(elmJson, null, 4) + '\n');
-  } catch (error) {
-    throw new Error(
-      `${elmJsonPath}\nFailed to write elm.json:\n${error.message}`
-    );
-  }
-}
-
-function read(dir /*: string */) /*: typeof ElmJson */ {
-  const elmJsonPath = getPath(dir);
-
-  try {
-    return readHelper(elmJsonPath);
-  } catch (error) {
-    throw new Error(
-      `${elmJsonPath}\nFailed to read elm.json:\n${error.message}`
-    );
-  }
-}
-
-function readHelper(elmJsonPath /*: string */) /*: typeof ElmJson */ {
-  const json = parseObject(
-    JSON.parse(fs.readFileSync(elmJsonPath, 'utf8')),
-    'the file'
-  );
-
-  switch (json.type) {
-    case 'application':
-      return {
-        ...json,
-        type: 'application',
-        'source-directories': parseSourceDirectories(
-          json['source-directories']
-        ),
-        dependencies: parseDirectAndIndirectDependencies(
-          json.dependencies,
-          'dependencies'
-        ),
-        'test-dependencies': parseDirectAndIndirectDependencies(
-          json['test-dependencies'],
-          'test-dependencies'
-        ),
-      };
-
-    case 'package':
-      return {
-        ...json,
-        type: 'package',
-        dependencies: parseDependencies(json.dependencies, 'dependencies'),
-        'test-dependencies': parseDependencies(
-          json['test-dependencies'],
-          'test-dependencies'
-        ),
-      };
-
-    default:
-      throw new Error(
-        `Expected "type" to be "application" or "package", but got: ${stringify(
-          json.type
-        )}`
-      );
-  }
-}
-
-function parseSourceDirectories(json /*: mixed */) /*: Array<string> */ {
-  if (!Array.isArray(json)) {
-    throw new Error(
-      `Expected "source-directories" to be an array, but got: ${stringify(
-        json
-      )}`
-    );
-  }
-
-  const result = [];
-
-  for (const [index, item] of json.entries()) {
-    if (typeof item !== 'string') {
-      throw new Error(
-        `Expected "source-directories"->${index} to be a string, but got: ${stringify(
-          item
-        )}`
-      );
-    }
-    result.push(item);
-  }
-
-  if (result.length === 0) {
-    throw new Error(
-      'Expected "source-directories" to contain at least one item, but it is empty.'
-    );
-  }
-
-  return result;
-}
-
-function parseDirectAndIndirectDependencies(
-  json /*: mixed */,
-  what /*: string */
-) /*: typeof DirectAndIndirectDependencies */ {
-  const jsonObject = parseObject(json, what);
-  return {
-    direct: parseDependencies(jsonObject.direct, `${what}->"direct"`),
-    indirect: parseDependencies(jsonObject.indirect, `${what}->"indirect"`),
-  };
-}
-
-function parseDependencies(
-  json /*: mixed */,
-  what /*: string */
-) /*: typeof Dependencies */ {
-  const jsonObject = parseObject(json, what);
-  const result = {};
-
-  for (const [key, value] of Object.entries(jsonObject)) {
-    if (typeof value !== 'string') {
-      throw new Error(
-        `Expected ${what}->${stringify(
-          key
-        )} to be a string, but got: ${stringify(value)}`
-      );
-    }
-    result[key] = value;
-  }
-
-  return result;
-}
-
-function parseObject(
-  json /*: mixed */,
-  what /*: string */
-) /*: { +[string]: mixed } */ {
-  if (json == null || typeof json !== 'object' || Array.isArray(json)) {
-    throw new Error(
-      `Expected ${what} to be an object, but got: ${stringify(json)}`
-    );
-  }
-  return json;
-}
-
-function stringify(json /*: mixed */) /*: string */ {
-  const maybeString = JSON.stringify(json);
-  return maybeString === undefined ? 'undefined' : maybeString;
-}
-
-module.exports = {
-  Dependencies,
-  DirectAndIndirectDependencies,
-  ElmJson,
-  getPath,
-  parseDirectAndIndirectDependencies,
-  read,
-  write,
-};