flingit 0.0.63 → 0.0.66

package/node_modules/@glideapps/ts-necessities/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 typeguard, Inc.
+
+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.

package/node_modules/@glideapps/ts-necessities/README.md

@@ -0,0 +1,16 @@
+# TS Necessities
+
+[![CI](https://github.com/glideapps/ts-necessities/actions/workflows/ci.yml/badge.svg)](https://github.com/glideapps/ts-necessities/actions/workflows/ci.yml)
+[![Docs](https://img.shields.io/badge/docs-TypeDoc-blue)](https://glideapps.github.io/ts-necessities/)
+
+These are some very basic functions and classes that we use at [Glide](https://glideapps.com/) to make coding with TypeScript easier and safer.
+
+[📚 API Documentation](https://glideapps.github.io/ts-necessities/)
+
+## Installation
+
+To add the package to your own project:
+
+```shell
+$ npm install @glideapps/ts-necessities
+```

package/node_modules/@glideapps/ts-necessities/dist/branded-strings.d.ts

@@ -0,0 +1,39 @@
+/**
+ * A branded string is a string that has a unique type, so that it can be
+ * distinguished from other strings.  This is useful when you want to ensure
+ * that a string is only used in a specific context.  When assigning to a
+ * branded string type it's not allowed to assign a non-branded string, or a
+ * string of the wrong brand:
+ *
+ * ```ts
+ * type Apple = BrandedString<"apple">;
+ * type Orange = BrandedString<"orange">;
+ *
+ * const apple: Apple = brandString("Pink Lady");
+ * let orange: Orange = apple;           // error!
+ * orange = "jalapeño";                  // error!
+ * let justAString: string = apple;      // This is ok
+ * ```
+ */
+export type BrandedString<T extends string> = string & {
+    __brand: T;
+};
+/**
+ * Brands a string with the specified brand.
+ *
+ * @param s The string to brand.
+ */
+export declare function brandString<T extends string>(s: string): BrandedString<T>;
+/**
+ * Returns a function that brands a string with the specified brand.  For
+ * example:
+ *
+ * ```ts
+ * type Apple = BrandedString<"apple">;
+ * // `makeApple` will be of type `(s: string) => Apple`
+ * const makeApple = makeBrandString<Apple>();
+ * // `apple` will be of type `Apple`
+ * const apple = makeApple("Pink Lady");
+ * ```
+ */
+export declare function makeBrandString<T>(): T extends BrandedString<string> ? (s: string) => T : never;

package/node_modules/@glideapps/ts-necessities/dist/default-map.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The read-only interface of [[DefaultMap]].
+ *
+ * @typeParam K The key type.
+ * @typeParam V The value type.
+ */
+export interface ReadonlyDefaultMap<K, V> extends ReadonlyMap<K, V> {
+    get(k: K): V;
+}
+/**
+ * A `Map` that returns default values for keys that are not present.
+ *
+ * To map strings to `Set`s of numbers, for example, `DefaultMap` can
+ * be used like this:
+ *
+ * ```
+ * const m = new DefaultMap<string, Set<number>>(() => new Set());
+ * m.get("foo"); // returns an empty `Set`
+ * m.get("bar").add(1);
+ * m.get("bar"); // returns a `Set` containing `1`.
+ * ```
+ *
+ * @typeParam K The key type.
+ * @typeParam V The value type.
+ */
+export declare class DefaultMap<K, V> extends Map<K, V> implements ReadonlyDefaultMap<K, V> {
+    private readonly _defaultFunc;
+    /**
+     *
+     * @param _defaultFunc Must return the default value for key `k`.  Will only be called when necessary.
+     * @param initKVPs An array of [key, value] arrays to initialize the map with.
+     */
+    constructor(_defaultFunc: (k: K) => V, initKVPs?: readonly (readonly [K, V])[]);
+    /**
+     * Returns the value for `k`.  If `k` is not present, creates
+     * the default value via [[_defaultFunc]], sets that default
+     * as the value for `k` and returns it.
+     */
+    get(k: K): V;
+    /**
+     * Sets the value for `k` to `f(v)` where `v` is the previous
+     * value for `k`, or the default if not present.  Returns the new
+     * value.
+     *
+     * These two lines are equivalent:
+     *
+     * ```
+     * m.set("foo", m.get("foo") + 1);
+     * m.update("foo", x => x + 1);
+     * ```
+     */
+    update(k: K, f: (v: V) => V): V;
+}

package/node_modules/@glideapps/ts-necessities/dist/index.d.mts

@@ -0,0 +1,113 @@
+/**
+ * Do nothing, but only compile if `_val` is of type `T`.
+ */
+export declare function proveType<T>(_val: T): void;
+/**
+ * Only compile if `_never` has type `never`.  If run, trace the
+ * `message` and return `result`.
+ */
+export declare function proveNever<T>(_never: never, message: string, result: T): never;
+/**
+ * Throw an `Error` and trace `message`.
+ */
+export declare function panic(message?: string): never;
+/**
+ * Assert that `fact` is `true`.  If the assertion fails, [[panic]]
+ * with `message`.
+ */
+export declare function assert(fact: boolean, message?: string): asserts fact;
+/**
+ * Only compile if `_never` has the type `never`.  If run, [[panic]]
+ * with `message`.
+ */
+export declare function assertNever(_never: never, message?: string): never;
+/**
+ * If `v` is not `undefined`, return `v`.  Otherwise, [[panic]] with
+ * a message including `reason`.
+ */
+export declare function defined<T>(v: T | undefined, reason?: string): T;
+/**
+ * The only thing this function does is to trace if the promise
+ * `p` rejects.  It is useful to explain to ESLint that `p` is
+ * intentionally not `await`ed.
+ *
+ * @deprecated Instead of `dontAwait(x)` use `void x`.
+ */
+export declare function dontAwait<T>(p: Promise<T> | T): void;
+/**
+ * A promise that resolves after `ms` milliseconds.
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * If both `a` and `b` are `undefined`, return `undefined`.
+ * If exactly one of the two is `undefined`, return the other.
+ * If both are not `undefined`, return `f(a, b)`.
+ */
+export declare function reduceTwo<T>(a: T | undefined, b: T | undefined, f: (aa: T, bb: T) => T): T | undefined;
+/**
+ * Remove `readonly` from all properties of `T`.
+ */
+export type Writable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export type DeepWritable<T> = {
+    -readonly [P in keyof T]: DeepWritable<T[P]>;
+};
+export type DeepReadonly<T> = {
+    readonly [P in keyof T]: DeepReadonly<T[P]>;
+};
+/**
+ * If `x` is undefined, return `undefined`.  Otherwise, return `f(x)`.
+ */
+export declare function definedMap<T, U>(x: T | undefined, f: (xx: T) => U): U | undefined;
+/**
+ * If `x` belongs to the enum `e`, return `true`.  Otherwise, return `false`.
+ */
+export declare function isEnumValue<T extends object>(e: T, x: unknown): x is T[keyof T];
+/**
+ * Returns whether `x` is an array.
+ *
+ * We have this because `Array.isArray(x)` returns `x is any[]`, which means
+ * that this code compiles without error, for example:
+ *
+ * ```typescript
+ * function thisShouldNotCompile(x: string | readonly string[]) {
+ *     if (Array.isArray(x)) {
+ *         const s = x[0];
+ *         s.thisIsAnAny("but it's actually a string");
+ *     }
+ * }
+ * ```
+ */
+export declare function isArray<T, U>(x: readonly T[] | U): x is readonly T[];
+export declare function isArray<T, U>(x: T[] | U): x is T[];
+/**
+ * Returns whether `obj` has `name` as its own property.
+ */
+export declare function hasOwnProperty<T extends string>(obj: unknown, name: T): obj is {
+    [P in T]: unknown;
+};
+/**
+ * Map `f` over `iterable`, and return an array of all results
+ * that are not `undefined`.
+ */
+export declare function mapFilterUndefined<T, U>(iterable: Iterable<T>, f: (x: T, i: number) => U | undefined): U[];
+/**
+ * Filters out all elements in `arr` that are `undefined`.
+ */
+export declare function filterUndefined<T>(arr: Iterable<T | undefined>): T[];
+export declare function mapRecord<T, U>(r: Record<string, T>, f: (v: T, n: string) => U): Record<string, U>;
+export declare function mapRecordFilterUndefined<T, U>(r: Record<string, T>, f: (v: T, n: string) => U | undefined): Record<string, U>;
+/**
+ * Returns a string representation of `e`, which is supposed to be an
+ * exception.
+ */
+export declare function exceptionToString(e: unknown): string;
+/**
+ * Returns the exception `e` as an instance of `Error`.  If `e` is already an
+ * `Error`, it just returns `e`, otherwise it returns an error with
+ * `exceptionToString(e)`.
+ */
+export declare function exceptionToError(e: unknown): Error;
+export { DefaultMap, ReadonlyDefaultMap } from "./default-map";
+export { BrandedString, brandString, makeBrandString } from "./branded-strings";

package/node_modules/@glideapps/ts-necessities/dist/index.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Do nothing, but only compile if `_val` is of type `T`.
+ */
+export declare function proveType<T>(_val: T): void;
+/**
+ * Only compile if `_never` has type `never`.  If run, trace the
+ * `message` and return `result`.
+ */
+export declare function proveNever<T>(_never: never, message: string, result: T): never;
+/**
+ * Throw an `Error` and trace `message`.
+ */
+export declare function panic(message?: string): never;
+/**
+ * Assert that `fact` is `true`.  If the assertion fails, [[panic]]
+ * with `message`.
+ */
+export declare function assert(fact: boolean, message?: string): asserts fact;
+/**
+ * Only compile if `_never` has the type `never`.  If run, [[panic]]
+ * with `message`.
+ */
+export declare function assertNever(_never: never, message?: string): never;
+/**
+ * If `v` is not `undefined`, return `v`.  Otherwise, [[panic]] with
+ * a message including `reason`.
+ */
+export declare function defined<T>(v: T | undefined, reason?: string): T;
+/**
+ * The only thing this function does is to trace if the promise
+ * `p` rejects.  It is useful to explain to ESLint that `p` is
+ * intentionally not `await`ed.
+ *
+ * @deprecated Instead of `dontAwait(x)` use `void x`.
+ */
+export declare function dontAwait<T>(p: Promise<T> | T): void;
+/**
+ * A promise that resolves after `ms` milliseconds.
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * If both `a` and `b` are `undefined`, return `undefined`.
+ * If exactly one of the two is `undefined`, return the other.
+ * If both are not `undefined`, return `f(a, b)`.
+ */
+export declare function reduceTwo<T>(a: T | undefined, b: T | undefined, f: (aa: T, bb: T) => T): T | undefined;
+/**
+ * Remove `readonly` from all properties of `T`.
+ */
+export type Writable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export type DeepWritable<T> = {
+    -readonly [P in keyof T]: DeepWritable<T[P]>;
+};
+export type DeepReadonly<T> = {
+    readonly [P in keyof T]: DeepReadonly<T[P]>;
+};
+/**
+ * If `x` is undefined, return `undefined`.  Otherwise, return `f(x)`.
+ */
+export declare function definedMap<T, U>(x: T | undefined, f: (xx: T) => U): U | undefined;
+/**
+ * If `x` belongs to the enum `e`, return `true`.  Otherwise, return `false`.
+ */
+export declare function isEnumValue<T extends object>(e: T, x: unknown): x is T[keyof T];
+/**
+ * Returns whether `x` is an array.
+ *
+ * We have this because `Array.isArray(x)` returns `x is any[]`, which means
+ * that this code compiles without error, for example:
+ *
+ * ```typescript
+ * function thisShouldNotCompile(x: string | readonly string[]) {
+ *     if (Array.isArray(x)) {
+ *         const s = x[0];
+ *         s.thisIsAnAny("but it's actually a string");
+ *     }
+ * }
+ * ```
+ */
+export declare function isArray<T, U>(x: readonly T[] | U): x is readonly T[];
+export declare function isArray<T, U>(x: T[] | U): x is T[];
+/**
+ * Returns whether `obj` has `name` as its own property.
+ */
+export declare function hasOwnProperty<T extends string>(obj: unknown, name: T): obj is {
+    [P in T]: unknown;
+};
+/**
+ * Map `f` over `iterable`, and return an array of all results
+ * that are not `undefined`.
+ */
+export declare function mapFilterUndefined<T, U>(iterable: Iterable<T>, f: (x: T, i: number) => U | undefined): U[];
+/**
+ * Filters out all elements in `arr` that are `undefined`.
+ */
+export declare function filterUndefined<T>(arr: Iterable<T | undefined>): T[];
+export declare function mapRecord<T, U>(r: Record<string, T>, f: (v: T, n: string) => U): Record<string, U>;
+export declare function mapRecordFilterUndefined<T, U>(r: Record<string, T>, f: (v: T, n: string) => U | undefined): Record<string, U>;
+/**
+ * Returns a string representation of `e`, which is supposed to be an
+ * exception.
+ */
+export declare function exceptionToString(e: unknown): string;
+/**
+ * Returns the exception `e` as an instance of `Error`.  If `e` is already an
+ * `Error`, it just returns `e`, otherwise it returns an error with
+ * `exceptionToString(e)`.
+ */
+export declare function exceptionToError(e: unknown): Error;
+export { DefaultMap, ReadonlyDefaultMap } from "./default-map";
+export { BrandedString, brandString, makeBrandString } from "./branded-strings";

package/node_modules/@glideapps/ts-necessities/dist/index.js

@@ -0,0 +1,237 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DefaultMap: () => DefaultMap,
+  assert: () => assert,
+  assertNever: () => assertNever,
+  brandString: () => brandString,
+  defined: () => defined,
+  definedMap: () => definedMap,
+  dontAwait: () => dontAwait,
+  exceptionToError: () => exceptionToError,
+  exceptionToString: () => exceptionToString,
+  filterUndefined: () => filterUndefined,
+  hasOwnProperty: () => hasOwnProperty,
+  isArray: () => isArray,
+  isEnumValue: () => isEnumValue,
+  makeBrandString: () => makeBrandString,
+  mapFilterUndefined: () => mapFilterUndefined,
+  mapRecord: () => mapRecord,
+  mapRecordFilterUndefined: () => mapRecordFilterUndefined,
+  panic: () => panic,
+  proveNever: () => proveNever,
+  proveType: () => proveType,
+  reduceTwo: () => reduceTwo,
+  sleep: () => sleep
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/default-map.ts
+var DefaultMap = class extends Map {
+  /**
+   *
+   * @param _defaultFunc Must return the default value for key `k`.  Will only be called when necessary.
+   * @param initKVPs An array of [key, value] arrays to initialize the map with.
+   */
+  constructor(_defaultFunc, initKVPs) {
+    super(initKVPs);
+    this._defaultFunc = _defaultFunc;
+  }
+  /**
+   * Returns the value for `k`.  If `k` is not present, creates
+   * the default value via [[_defaultFunc]], sets that default
+   * as the value for `k` and returns it.
+   */
+  get(k) {
+    let v = super.get(k);
+    if (v === void 0) {
+      if (this.has(k)) return v;
+      v = this._defaultFunc(k);
+      this.set(k, v);
+    }
+    return v;
+  }
+  /**
+   * Sets the value for `k` to `f(v)` where `v` is the previous
+   * value for `k`, or the default if not present.  Returns the new
+   * value.
+   *
+   * These two lines are equivalent:
+   *
+   * ```
+   * m.set("foo", m.get("foo") + 1);
+   * m.update("foo", x => x + 1);
+   * ```
+   */
+  update(k, f) {
+    const v = f(this.get(k));
+    this.set(k, v);
+    return v;
+  }
+};
+
+// src/branded-strings.ts
+function brandString(s) {
+  return s;
+}
+function makeBrandString() {
+  return brandString;
+}
+
+// src/index.ts
+function proveType(_val) {
+}
+function proveNever(_never, message, result) {
+  console.trace(message);
+  return result;
+}
+function panic(message = "This should not happen") {
+  console.trace(message);
+  throw new Error(message);
+}
+function assert(fact, message = "Assertion failed") {
+  if (fact) return;
+  return panic(message);
+}
+function assertNever(_never, message = "`never` happened") {
+  return panic(message);
+}
+function defined(v, reason) {
+  if (v === void 0) {
+    return panic("Value was undefined but should be defined" + (reason !== void 0 ? ` because: ${reason}` : ""));
+  }
+  return v;
+}
+function dontAwait(p) {
+  if (!(p instanceof Promise)) return;
+  p.catch((e) => {
+    console.trace("Unhandled error from unawaited promise", e);
+    throw e;
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function reduceTwo(a, b, f) {
+  if (a === void 0) return b;
+  if (b === void 0) return a;
+  return f(a, b);
+}
+function definedMap(x, f) {
+  if (x === void 0) return void 0;
+  return f(x);
+}
+function isEnumValue(e, x) {
+  return Object.keys(e).map((k) => e[k]).some((v) => v === x);
+}
+function isArray(x) {
+  return Array.isArray(x);
+}
+function hasOwnProperty(obj, name) {
+  if (obj === void 0 || obj === null) return false;
+  return Object.prototype.hasOwnProperty.call(obj, name);
+}
+function mapFilterUndefined(iterable, f) {
+  const result = [];
+  let i = 0;
+  for (const x of iterable) {
+    const y = f(x, i);
+    i += 1;
+    if (y === void 0) continue;
+    result.push(y);
+  }
+  return result;
+}
+function filterUndefined(arr) {
+  const result = [];
+  for (const x of arr) {
+    if (x !== void 0) {
+      result.push(x);
+    }
+  }
+  return result;
+}
+function mapRecord(r, f) {
+  const result = {};
+  for (const [name, value] of Object.entries(r)) {
+    result[name] = f(value, name);
+  }
+  return result;
+}
+function mapRecordFilterUndefined(r, f) {
+  const result = {};
+  for (const [name, value] of Object.entries(r)) {
+    const o = f(value, name);
+    if (o === void 0) continue;
+    result[name] = o;
+  }
+  return result;
+}
+function exceptionToString(e) {
+  if (e === void 0) return "";
+  if (hasOwnProperty(e, "message") && typeof e.message === "string") {
+    return e.message;
+  }
+  try {
+    return e.toString();
+  } catch (f) {
+    try {
+      return `Exception can't be stringified: ${exceptionToString(f)}`;
+    } catch (e2) {
+      return "Exception can't be stringified";
+    }
+  }
+}
+function exceptionToError(e) {
+  if (e instanceof Error) {
+    return e;
+  } else {
+    return new Error(exceptionToString(e));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DefaultMap,
+  assert,
+  assertNever,
+  brandString,
+  defined,
+  definedMap,
+  dontAwait,
+  exceptionToError,
+  exceptionToString,
+  filterUndefined,
+  hasOwnProperty,
+  isArray,
+  isEnumValue,
+  makeBrandString,
+  mapFilterUndefined,
+  mapRecord,
+  mapRecordFilterUndefined,
+  panic,
+  proveNever,
+  proveType,
+  reduceTwo,
+  sleep
+});