Projektstart

backend/node_modules/joycon/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) egoist <0x142857@gmail.com> (https://github.com/egoist)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

backend/node_modules/joycon/README.md

@@ -0,0 +1,133 @@
+
+# joycon
+
+[![NPM version](https://img.shields.io/npm/v/joycon.svg?style=flat)](https://npmjs.com/package/joycon) [![NPM downloads](https://img.shields.io/npm/dm/joycon.svg?style=flat)](https://npmjs.com/package/joycon) [![install size](https://packagephobia.now.sh/badge?p=joycon@2.0.0)](https://packagephobia.now.sh/result?p=joycon@2.0.0) [![CircleCI](https://circleci.com/gh/egoist/joycon/tree/master.svg?style=shield)](https://circleci.com/gh/egoist/joycon/tree/master)  [![donate](https://img.shields.io/badge/$-donate-ff69b4.svg?maxAge=2592000&style=flat)](https://github.com/egoist/donate) [![chat](https://img.shields.io/badge/chat-on%20discord-7289DA.svg?style=flat)](https://chat.egoist.moe)
+
+## Differences with [cosmiconfig](https://github.com/davidtheclark/cosmiconfig)?
+
+JoyCon is zero-dependency but feature-complete.
+
+## Install
+
+```bash
+yarn add joycon
+```
+
+## Usage
+
+```js
+const JoyCon = require('joycon')
+
+const joycon = new JoyCon()
+
+joycon.load(['package-lock.json', 'yarn.lock'])
+.then(result => {
+  // result is {} when files do not exist
+  // otherwise { path, data }
+})
+```
+
+By default non-js files are parsed as JSON, if you want something different you can add a loader:
+
+```js
+const joycon = new JoyCon()
+
+joycon.addLoader({
+  test: /\.toml$/,
+  load(filepath) {
+    return require('toml').parse(filepath)
+  }
+})
+
+joycon.load(['cargo.toml'])
+```
+
+## API
+
+### constructor([options])
+
+#### options
+
+##### files
+
+- Type: `string[]`
+
+The files to search.
+
+##### cwd
+
+The directory to search files.
+
+##### stopDir
+
+The directory to stop searching.
+
+##### packageKey
+
+You can load config from certain property in a `package.json` file. For example, when you set `packageKey: 'babel'`, it will load the `babel` property in `package.json` instead of the entire data.
+
+##### parseJSON
+
+- Type: `(str: string) => any`
+- Default: `JSON.parse`
+
+The function used to parse JSON string.
+
+### resolve([files], [cwd], [stopDir])
+### resolve([options])
+
+`files` defaults to `options.files`.
+
+`cwd` defaults to `options.cwd`.
+
+`stopDir` defaults to `options.stopDir` then `path.parse(cwd).root`.
+
+If using a single object `options`, it will be the same as constructor options.
+
+Search files and resolve the path of the file we found.
+
+There's also `.resolveSync` method.
+
+### load(...args)
+
+The signature is the same as [resolve](#resolvefiles-cwd-stopdir).
+
+Search files and resolve `{ path, data }` of the file we found.
+
+There's also `.loadSync` method.
+
+### addLoader(Loader)
+
+```typescript
+interface Loader {
+  name?: string
+  test: RegExp
+  load(filepath: string)?: Promise<any>
+  loadSync(filepath: string)?: any
+}
+```
+
+At least one of `load` and `loadSync` is required, depending on whether you're calling the synchonous methods or not.
+
+### removeLoader(name)
+
+Remove loaders by loader name.
+
+### clearCache()
+
+Each JoyCon instance uses its own cache.
+
+## Contributing
+
+1. Fork it!
+2. Create your feature branch: `git checkout -b my-new-feature`
+3. Commit your changes: `git commit -am 'Add some feature'`
+4. Push to the branch: `git push origin my-new-feature`
+5. Submit a pull request :D
+
+## Author
+
+**joycon** © [egoist](https://github.com/egoist), Released under the [MIT](./LICENSE) License.<br>
+Authored and maintained by egoist with help from contributors ([list](https://github.com/egoist/joycon/contributors)).
+
+> [github.com/egoist](https://github.com/egoist) · GitHub [@egoist](https://github.com/egoist) · Twitter [@_egoistlily](https://twitter.com/_egoistlily)

backend/node_modules/joycon/lib/index.js

@@ -0,0 +1,286 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const readFileSync = fp => {
+  return _fs.default.readFileSync(fp, 'utf8');
+};
+
+const pathExists = fp => new Promise(resolve => {
+  _fs.default.access(fp, err => {
+    resolve(!err);
+  });
+});
+
+const pathExistsSync = _fs.default.existsSync;
+
+class JoyCon {
+  constructor({
+    files,
+    cwd = process.cwd(),
+    stopDir,
+    packageKey,
+    parseJSON = JSON.parse
+  } = {}) {
+    this.options = {
+      files,
+      cwd,
+      stopDir,
+      packageKey,
+      parseJSON
+    };
+    this.existsCache = new Map();
+    this.loaders = new Set();
+    this.packageJsonCache = new Map();
+    this.loadCache = new Map();
+  }
+
+  addLoader(loader) {
+    this.loaders.add(loader);
+    return this;
+  }
+
+  removeLoader(name) {
+    for (const loader of this.loaders) {
+      if (name && loader.name === name) {
+        this.loaders.delete(loader);
+      }
+    }
+
+    return this;
+  }
+
+  async recusivelyResolve(options) {
+    if (options.cwd === options.stopDir || _path.default.basename(options.cwd) === 'node_modules') {
+      return null;
+    }
+
+    for (const filename of options.files) {
+      const file = _path.default.resolve(options.cwd, filename);
+
+      const exists = process.env.NODE_ENV !== 'test' && this.existsCache.has(file) ? this.existsCache.get(file) : await pathExists(file);
+      this.existsCache.set(file, exists);
+
+      if (exists) {
+        if (!options.packageKey || _path.default.basename(file) !== 'package.json') {
+          return file;
+        }
+
+        const data = require(file);
+
+        delete require.cache[file];
+        const hasPackageKey = Object.prototype.hasOwnProperty.call(data, options.packageKey);
+
+        if (hasPackageKey) {
+          this.packageJsonCache.set(file, data);
+          return file;
+        }
+      }
+
+      continue;
+    }
+
+    return this.recusivelyResolve(Object.assign({}, options, {
+      cwd: _path.default.dirname(options.cwd)
+    }));
+  }
+
+  recusivelyResolveSync(options) {
+    if (options.cwd === options.stopDir || _path.default.basename(options.cwd) === 'node_modules') {
+      return null;
+    }
+
+    for (const filename of options.files) {
+      const file = _path.default.resolve(options.cwd, filename);
+
+      const exists = process.env.NODE_ENV !== 'test' && this.existsCache.has(file) ? this.existsCache.get(file) : pathExistsSync(file);
+      this.existsCache.set(file, exists);
+
+      if (exists) {
+        if (!options.packageKey || _path.default.basename(file) !== 'package.json') {
+          return file;
+        }
+
+        const data = require(file);
+
+        delete require.cache[file];
+        const hasPackageKey = Object.prototype.hasOwnProperty.call(data, options.packageKey);
+
+        if (hasPackageKey) {
+          this.packageJsonCache.set(file, data);
+          return file;
+        }
+      }
+
+      continue;
+    }
+
+    return this.recusivelyResolveSync(Object.assign({}, options, {
+      cwd: _path.default.dirname(options.cwd)
+    }));
+  }
+
+  async resolve(...args) {
+    const options = this.normalizeOptions(args);
+    return this.recusivelyResolve(options);
+  }
+
+  resolveSync(...args) {
+    const options = this.normalizeOptions(args);
+    return this.recusivelyResolveSync(options);
+  }
+
+  runLoaderSync(loader, filepath) {
+    return loader.loadSync(filepath);
+  }
+
+  runLoader(loader, filepath) {
+    if (!loader.load) return loader.loadSync(filepath);
+    return loader.load(filepath);
+  }
+
+  async load(...args) {
+    const options = this.normalizeOptions(args);
+    const filepath = await this.recusivelyResolve(options);
+
+    if (filepath) {
+      const defaultLoader = {
+        test: /\.+/,
+        loadSync: filepath => {
+          const extname = _path.default.extname(filepath).slice(1);
+
+          if (extname === 'js' || extname === 'cjs') {
+            delete require.cache[filepath];
+            return require(filepath);
+          }
+
+          if (this.packageJsonCache.has(filepath)) {
+            return this.packageJsonCache.get(filepath)[options.packageKey];
+          }
+
+          const data = this.options.parseJSON(readFileSync(filepath));
+          return data;
+        }
+      };
+      const loader = this.findLoader(filepath) || defaultLoader;
+      let data;
+
+      if (this.loadCache.has(filepath)) {
+        data = this.loadCache.get(filepath);
+      } else {
+        data = await this.runLoader(loader, filepath);
+        this.loadCache.set(filepath, data);
+      }
+
+      return {
+        path: filepath,
+        data
+      };
+    }
+
+    return {};
+  }
+
+  loadSync(...args) {
+    const options = this.normalizeOptions(args);
+    const filepath = this.recusivelyResolveSync(options);
+
+    if (filepath) {
+      const defaultLoader = {
+        test: /\.+/,
+        loadSync: filepath => {
+          const extname = _path.default.extname(filepath).slice(1);
+
+          if (extname === 'js' || extname === 'cjs') {
+            delete require.cache[filepath];
+            return require(filepath);
+          }
+
+          if (this.packageJsonCache.has(filepath)) {
+            return this.packageJsonCache.get(filepath)[options.packageKey];
+          }
+
+          const data = this.options.parseJSON(readFileSync(filepath));
+          return data;
+        }
+      };
+      const loader = this.findLoader(filepath) || defaultLoader;
+      let data;
+
+      if (this.loadCache.has(filepath)) {
+        data = this.loadCache.get(filepath);
+      } else {
+        data = this.runLoaderSync(loader, filepath);
+        this.loadCache.set(filepath, data);
+      }
+
+      return {
+        path: filepath,
+        data
+      };
+    }
+
+    return {};
+  }
+
+  findLoader(filepath) {
+    for (const loader of this.loaders) {
+      if (loader.test && loader.test.test(filepath)) {
+        return loader;
+      }
+    }
+
+    return null;
+  }
+
+  clearCache() {
+    this.existsCache.clear();
+    this.packageJsonCache.clear();
+    this.loadCache.clear();
+    return this;
+  }
+
+  normalizeOptions(args) {
+    const options = Object.assign({}, this.options);
+
+    if (Object.prototype.toString.call(args[0]) === '[object Object]') {
+      Object.assign(options, args[0]);
+    } else {
+      if (args[0]) {
+        options.files = args[0];
+      }
+
+      if (args[1]) {
+        options.cwd = args[1];
+      }
+
+      if (args[2]) {
+        options.stopDir = args[2];
+      }
+    }
+
+    options.cwd = _path.default.resolve(options.cwd);
+    options.stopDir = options.stopDir ? _path.default.resolve(options.stopDir) : _path.default.parse(options.cwd).root;
+
+    if (!options.files || options.files.length === 0) {
+      throw new Error('[joycon] files must be an non-empty array!');
+    }
+
+    options.__normalized__ = true;
+    return options;
+  }
+
+}
+
+exports.default = JoyCon;
+module.exports = JoyCon;
+module.exports.default = JoyCon;

backend/node_modules/joycon/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "joycon",
+  "version": "3.1.1",
+  "description": "Load config with ease.",
+  "repository": {
+    "url": "egoist/joycon",
+    "type": "git"
+  },
+  "main": "lib/index.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "lib",
+    "types/index.d.ts"
+  ],
+  "scripts": {
+    "test": "jest --testPathPattern tests",
+    "build": "babel src -d lib --no-comments",
+    "prepublishOnly": "npm run build"
+  },
+  "author": "egoist <0x142857@gmail.com>",
+  "license": "MIT",
+  "jest": {
+    "testEnvironment": "node"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.13.10",
+    "@babel/core": "^7.13.10",
+    "@babel/preset-env": "^7.13.10",
+    "@egoist/prettier-config": "^0.1.0",
+    "@types/node": "^14.14.33",
+    "babel-jest": "^26.6.3",
+    "babel-plugin-sync": "^0.1.0",
+    "jest-cli": "^26.6.3",
+    "prettier": "^2.2.1"
+  },
+  "engines": {
+    "node": ">=10"
+  }
+}

backend/node_modules/joycon/types/index.d.ts

@@ -0,0 +1,62 @@
+export interface Options {
+  /* a list of files to search */
+  files?: string[]
+  /* the directory to search from */
+  cwd?: string
+  /* the directory to stop searching */
+  stopDir?: string
+  /* the key in package.json to read data at */
+  packageKey?: string
+  /* the function used to parse json */
+  parseJSON?: (str: string) => any
+}
+
+export interface LoadResult {
+  /* file path */
+  path?: string
+  /* file data */
+  data?: any
+}
+
+export interface AsyncLoader {
+  /** Optional loader name */
+  name?: string
+  test: RegExp
+  load(filepath: string): Promise<any>
+}
+
+export interface SyncLoader {
+  /** Optional loader name */
+  name?: string
+  test: RegExp
+  loadSync(filepath: string): any
+}
+
+export interface MultiLoader {
+  /** Optional loader name */
+  name?: string
+  test: RegExp
+  load(filepath: string): Promise<any>
+  loadSync(filepath: string): any
+}
+
+declare class JoyCon {
+  constructor(options?: Options)
+
+  options: Options
+
+  resolve(files?: string[] | Options, cwd?: string, stopDir?: string): Promise<string | null>
+  resolveSync(files?: string[] | Options, cwd?: string, stopDir?: string): string | null
+
+  load(files?: string[] | Options, cwd?: string, stopDir?: string): Promise<LoadResult>
+  loadSync(files?: string[] | Options, cwd?: string, stopDir?: string): LoadResult
+
+  addLoader(loader: AsyncLoader | SyncLoader | MultiLoader): this
+  removeLoader(name: string): this
+
+  /** Clear internal cache */
+  clearCache(): this
+}
+
+
+export default JoyCon