@flourish/sdk 4.2.0 → 4.2.2

package/my_template/node_modules/is-what/README.md

@@ -0,0 +1,191 @@
+# is What? 🙉
+
+Very simple & small JS type check functions. It's fully TypeScript supported!
+
+```
+npm i is-what
+```
+
+Or for deno available at: `"deno.land/x/is_what"`
+
+## Motivation
+
+I built is-what because the existing solutions were all too complex or too poorly built.
+
+I was looking for:
+- A simple way to check any kind of type (including non-primitives)
+- Be able to check if an object is a plain object `{}` or a special object (like a class instance) ‼️
+- Let TypeScript automatically know what type a value is when checking
+
+And that's exactly what `is-what` is! (what a great wordplay 😃)
+
+## Usage
+
+is-what is really easy to use, and most functions work just like you'd expect.
+
+```js
+// import functions you want to use like so:
+import { isString, isDate, isPlainObject } from 'is-what'
+```
+
+1. First I'll go over the simple functions available. Only `isNumber` and `isDate` have special treatment.
+2. After that I'll talk about working with Objects (plain objects vs class instances etc.).
+3. Lastly I'll talk about TypeScript implementation
+
+### Simple type check functions
+
+```js
+// strings
+isString('') // true
+isEmptyString('') // true
+isFullString('') // false
+
+// numbers
+isNumber(0) // true
+isNumber(NaN) // false
+
+// dates
+isDate(new Date()) // true
+isDate(new Date('invalid date')) // false
+
+// others
+isBoolean(false) // true
+isFunction(function () {}) // true
+isArray([]) // true
+isUndefined(undefined) // true
+isNull(null) // true
+isRegExp(/\s/gi) // true
+isSymbol(Symbol()) // true
+isBlob(new Blob()) // true
+isFile(new File([''], '', { type: 'text/html' })) // true
+
+// primitives
+isPrimitive('') // true
+// true for any of: boolean, null, undefined, number, string, symbol
+```
+
+### Getting and checking for specific types
+
+You can check for specific types with `getType` and `isType`:
+
+```js
+import { getType, isType } from 'is-what'
+
+getType('') // returns 'String'
+// pass a Type as second param:
+isType('', String) // returns true
+```
+
+### isPlainObject vs isAnyObject
+
+Checking for a JavaScript object can be really difficult. In JavaScript you can create classes that will behave just like JavaScript objects but might have completely different prototypes. With is-what I went for this classification:
+
+- `isPlainObject` will only return `true` on plain JavaScript objects and not on classes or others
+- `isAnyObject` will be more loose and return `true` on regular objects, classes, etc.
+
+```js
+// define a plain object
+const plainObject = {hello: 'I am a good old object.'}
+
+// define a special object
+class SpecialObject {
+  constructor (somethingSpecial) {
+    this.speciality = somethingSpecial
+  }
+}
+const specialObject = new SpecialObject('I am a special object! I am a class instance!!!')
+
+// check the plain object
+isPlainObject(plainObject) // returns true
+isAnyObject(plainObject) // returns true
+getType(plainObject) // returns 'Object'
+
+// check the special object
+isPlainObject(specialObject) // returns false !!!!!!!!!
+isAnyObject(specialObject) // returns true
+getType(specialObject) // returns 'Object'
+```
+
+> Please note that `isPlainObject` will only return `true` for normal plain JavaScript objects.
+
+## TypeScript
+
+is-what makes TypeScript know the type during if statements. This means that a check returns the type of the payload for TypeScript users.
+
+```ts
+function isNumber (payload: any): payload is number {
+  // return boolean
+}
+// As you can see above, all functions return a boolean for JavaScript, but pass the payload type to TypeScript.
+
+// usage example:
+function fn (payload: string | number): number {
+  if (isNumber(payload)) {
+    // ↑ TypeScript already knows payload is a number here!
+    return payload
+  }
+  return 0
+}
+```
+
+`isPlainObject` and `isAnyObject` with TypeScript will declare the payload to be an object type with any props:
+
+```ts
+function isPlainObject (payload: any): payload is {[key: string]: any}
+function isAnyObject (payload: any): payload is {[key: string]: any}
+// The reason to return `{[key: string]: any}` is to be able to do
+if (isPlainObject(payload) && payload.id) return payload.id
+// if isPlainObject() would return `payload is object` then it would give an error at `payload.id`
+```
+
+### isObjectLike
+
+If you want more control over which kind of objects are allowed you can use `isObjectLike<T>`:
+
+```ts
+import { isObjectLike } from 'is-what'
+// usage examples:
+isObjectLike<{specificKey: string}>(payload)
+isObjectLike<object>(payload)
+// you can pass a specific type for TS to check on.
+```
+
+`isObjectLike<T>` works like this under the hood:
+
+```ts
+function isObjectLike<T extends object> (payload: any): payload is T {
+  return isAnyObject(payload)
+}
+```
+
+## Meet the family
+
+- [is-what 🙉](https://github.com/mesqueeb/is-what)
+- [merge-anything 🥡](https://github.com/mesqueeb/merge-anything)
+- [filter-anything ⚔️](https://github.com/mesqueeb/filter-anything)
+- [find-and-replace-anything 🎣](https://github.com/mesqueeb/find-and-replace-anything)
+- [compare-anything 🛰](https://github.com/mesqueeb/compare-anything)
+- [copy-anything 🎭](https://github.com/mesqueeb/copy-anything)
+- [flatten-anything 🏏](https://github.com/mesqueeb/flatten-anything)
+
+## Source code
+
+It's litterally just these functions:
+
+```js
+function getType (payload) {
+  return Object.prototype.toString.call(payload).slice(8, -1)
+}
+function isUndefined (payload) {
+  return getType(payload) === 'Undefined'
+}
+function isString (payload) {
+  return getType(payload) === 'String'
+}
+function isAnyObject (payload) {
+  return getType(payload) === 'Object'
+}
+// etc...
+```
+
+See the full source code [here](https://github.com/mesqueeb/is-what/blob/master/src/index.ts).

package/my_template/node_modules/is-what/build.js

@@ -0,0 +1,60 @@
+/* eslint-disable */
+
+// npm install rollup-plugin-typescript2 typescript --save-dev
+import typescript from 'rollup-plugin-typescript2'
+// import { terser } from 'rollup-plugin-terser'
+// import resolve from 'rollup-plugin-node-resolve'
+
+// ------------------------------------------------------------------------------------------
+// formats
+// ------------------------------------------------------------------------------------------
+// amd – Asynchronous Module Definition, used with module loaders like RequireJS
+// cjs – CommonJS, suitable for Node and Browserify/Webpack
+// esm – Keep the bundle as an ES module file
+// iife – A self-executing function, suitable for inclusion as a <script> tag. (If you want to create a bundle for your application, you probably want to use this, because it leads to smaller file sizes.)
+// umd – Universal Module Definition, works as amd, cjs and iife all in one
+// system – Native format of the SystemJS loader
+
+// ------------------------------------------------------------------------------------------
+// setup
+// ------------------------------------------------------------------------------------------
+const pkg = require('./package.json')
+const name = pkg.name
+const className = name.replace(/(^\w|-\w)/g, c => c.replace('-', '').toUpperCase())
+const external = Object.keys(pkg.dependencies || [])
+const plugins = [
+  typescript({ useTsconfigDeclarationDir: true, tsconfigOverride: { exclude: ['test/**/*'] } }),
+]
+
+// ------------------------------------------------------------------------------------------
+// Builds
+// ------------------------------------------------------------------------------------------
+function defaults (config) {
+  // defaults
+  const defaults = {
+    plugins,
+    external,
+  }
+  // defaults.output
+  config.output = config.output.map(output => {
+    return Object.assign(
+      {
+        sourcemap: false,
+        name: className,
+        exports: 'named',
+      },
+      output
+    )
+  })
+  return Object.assign(defaults, config)
+}
+
+export default [
+  defaults({
+    input: 'src/index.ts',
+    output: [
+      { file: 'dist/index.cjs.js', format: 'cjs' },
+      { file: 'dist/index.esm.js', format: 'esm' },
+    ],
+  }),
+]

package/my_template/node_modules/is-what/dist/index.cjs.js

@@ -0,0 +1,364 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Returns the object type of the given payload
+ *
+ * @param {*} payload
+ * @returns {string}
+ */
+function getType(payload) {
+    return Object.prototype.toString.call(payload).slice(8, -1);
+}
+/**
+ * Returns whether the payload is undefined
+ *
+ * @param {*} payload
+ * @returns {payload is undefined}
+ */
+function isUndefined(payload) {
+    return getType(payload) === 'Undefined';
+}
+/**
+ * Returns whether the payload is null
+ *
+ * @param {*} payload
+ * @returns {payload is null}
+ */
+function isNull(payload) {
+    return getType(payload) === 'Null';
+}
+/**
+ * Returns whether the payload is a plain JavaScript object (excluding special classes or objects with other prototypes)
+ *
+ * @param {*} payload
+ * @returns {payload is PlainObject}
+ */
+function isPlainObject(payload) {
+    if (getType(payload) !== 'Object')
+        return false;
+    return payload.constructor === Object && Object.getPrototypeOf(payload) === Object.prototype;
+}
+/**
+ * Returns whether the payload is a plain JavaScript object (excluding special classes or objects with other prototypes)
+ *
+ * @param {*} payload
+ * @returns {payload is PlainObject}
+ */
+function isObject(payload) {
+    return isPlainObject(payload);
+}
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other prototypes)
+ *
+ * @param {*} payload
+ * @returns {payload is { [K in any]: never }}
+ */
+function isEmptyObject(payload) {
+    return isPlainObject(payload) && Object.keys(payload).length === 0;
+}
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other prototypes)
+ *
+ * @param {*} payload
+ * @returns {payload is PlainObject}
+ */
+function isFullObject(payload) {
+    return isPlainObject(payload) && Object.keys(payload).length > 0;
+}
+/**
+ * Returns whether the payload is an any kind of object (including special classes or objects with different prototypes)
+ *
+ * @param {*} payload
+ * @returns {payload is PlainObject}
+ */
+function isAnyObject(payload) {
+    return getType(payload) === 'Object';
+}
+/**
+ * Returns whether the payload is an object like a type passed in < >
+ *
+ * Usage: isObjectLike<{id: any}>(payload) // will make sure it's an object and has an `id` prop.
+ *
+ * @template T this must be passed in < >
+ * @param {*} payload
+ * @returns {payload is T}
+ */
+function isObjectLike(payload) {
+    return isAnyObject(payload);
+}
+/**
+ * Returns whether the payload is a function (regular or async)
+ *
+ * @param {*} payload
+ * @returns {payload is AnyFunction}
+ */
+function isFunction(payload) {
+    return typeof payload === 'function';
+}
+/**
+ * Returns whether the payload is an array
+ *
+ * @param {any} payload
+ * @returns {payload is any[]}
+ */
+function isArray(payload) {
+    return getType(payload) === 'Array';
+}
+/**
+ * Returns whether the payload is a an array with at least 1 item
+ *
+ * @param {*} payload
+ * @returns {payload is any[]}
+ */
+function isFullArray(payload) {
+    return isArray(payload) && payload.length > 0;
+}
+/**
+ * Returns whether the payload is a an empty array
+ *
+ * @param {*} payload
+ * @returns {payload is []}
+ */
+function isEmptyArray(payload) {
+    return isArray(payload) && payload.length === 0;
+}
+/**
+ * Returns whether the payload is a string
+ *
+ * @param {*} payload
+ * @returns {payload is string}
+ */
+function isString(payload) {
+    return getType(payload) === 'String';
+}
+/**
+ * Returns whether the payload is a string, BUT returns false for ''
+ *
+ * @param {*} payload
+ * @returns {payload is string}
+ */
+function isFullString(payload) {
+    return isString(payload) && payload !== '';
+}
+/**
+ * Returns whether the payload is ''
+ *
+ * @param {*} payload
+ * @returns {payload is string}
+ */
+function isEmptyString(payload) {
+    return payload === '';
+}
+/**
+ * Returns whether the payload is a number (but not NaN)
+ *
+ * This will return `false` for `NaN`!!
+ *
+ * @param {*} payload
+ * @returns {payload is number}
+ */
+function isNumber(payload) {
+    return getType(payload) === 'Number' && !isNaN(payload);
+}
+/**
+ * Returns whether the payload is a boolean
+ *
+ * @param {*} payload
+ * @returns {payload is boolean}
+ */
+function isBoolean(payload) {
+    return getType(payload) === 'Boolean';
+}
+/**
+ * Returns whether the payload is a regular expression (RegExp)
+ *
+ * @param {*} payload
+ * @returns {payload is RegExp}
+ */
+function isRegExp(payload) {
+    return getType(payload) === 'RegExp';
+}
+/**
+ * Returns whether the payload is a Map
+ *
+ * @param {*} payload
+ * @returns {payload is Map<any, any>}
+ */
+function isMap(payload) {
+    return getType(payload) === 'Map';
+}
+/**
+ * Returns whether the payload is a WeakMap
+ *
+ * @param {*} payload
+ * @returns {payload is WeakMap<any, any>}
+ */
+function isWeakMap(payload) {
+    return getType(payload) === 'WeakMap';
+}
+/**
+ * Returns whether the payload is a Set
+ *
+ * @param {*} payload
+ * @returns {payload is Set<any>}
+ */
+function isSet(payload) {
+    return getType(payload) === 'Set';
+}
+/**
+ * Returns whether the payload is a WeakSet
+ *
+ * @param {*} payload
+ * @returns {payload is WeakSet<any>}
+ */
+function isWeakSet(payload) {
+    return getType(payload) === 'WeakSet';
+}
+/**
+ * Returns whether the payload is a Symbol
+ *
+ * @param {*} payload
+ * @returns {payload is symbol}
+ */
+function isSymbol(payload) {
+    return getType(payload) === 'Symbol';
+}
+/**
+ * Returns whether the payload is a Date, and that the date is valid
+ *
+ * @param {*} payload
+ * @returns {payload is Date}
+ */
+function isDate(payload) {
+    return getType(payload) === 'Date' && !isNaN(payload);
+}
+/**
+ * Returns whether the payload is a Blob
+ *
+ * @param {*} payload
+ * @returns {payload is Blob}
+ */
+function isBlob(payload) {
+    return getType(payload) === 'Blob';
+}
+/**
+ * Returns whether the payload is a File
+ *
+ * @param {*} payload
+ * @returns {payload is File}
+ */
+function isFile(payload) {
+    return getType(payload) === 'File';
+}
+/**
+ * Returns whether the payload is a Promise
+ *
+ * @param {*} payload
+ * @returns {payload is Promise<any>}
+ */
+function isPromise(payload) {
+    return getType(payload) === 'Promise';
+}
+/**
+ * Returns whether the payload is an Error
+ *
+ * @param {*} payload
+ * @returns {payload is Error}
+ */
+function isError(payload) {
+    return getType(payload) === 'Error';
+}
+/**
+ * Returns whether the payload is literally the value `NaN` (it's `NaN` and also a `number`)
+ *
+ * @param {*} payload
+ * @returns {payload is typeof NaN}
+ */
+function isNaNValue(payload) {
+    return getType(payload) === 'Number' && isNaN(payload);
+}
+/**
+ * Returns whether the payload is a primitive type (eg. Boolean | Null | Undefined | Number | String | Symbol)
+ *
+ * @param {*} payload
+ * @returns {(payload is boolean | null | undefined | number | string | symbol)}
+ */
+function isPrimitive(payload) {
+    return (isBoolean(payload) ||
+        isNull(payload) ||
+        isUndefined(payload) ||
+        isNumber(payload) ||
+        isString(payload) ||
+        isSymbol(payload));
+}
+/**
+ * Returns true whether the payload is null or undefined
+ *
+ * @param {*} payload
+ * @returns {(payload is null | undefined)}
+ */
+var isNullOrUndefined = isOneOf(isNull, isUndefined);
+function isOneOf(a, b, c, d, e) {
+    return function (value) {
+        return a(value) || b(value) || (!!c && c(value)) || (!!d && d(value)) || (!!e && e(value));
+    };
+}
+/**
+ * Does a generic check to check that the given payload is of a given type.
+ * In cases like Number, it will return true for NaN as NaN is a Number (thanks javascript!);
+ * It will, however, differentiate between object and null
+ *
+ * @template T
+ * @param {*} payload
+ * @param {T} type
+ * @throws {TypeError} Will throw type error if type is an invalid type
+ * @returns {payload is T}
+ */
+function isType(payload, type) {
+    if (!(type instanceof Function)) {
+        throw new TypeError('Type must be a function');
+    }
+    if (!Object.prototype.hasOwnProperty.call(type, 'prototype')) {
+        throw new TypeError('Type is not a class');
+    }
+    // Classes usually have names (as functions usually have names)
+    var name = type.name;
+    return getType(payload) === name || Boolean(payload && payload.constructor === type);
+}
+
+exports.getType = getType;
+exports.isAnyObject = isAnyObject;
+exports.isArray = isArray;
+exports.isBlob = isBlob;
+exports.isBoolean = isBoolean;
+exports.isDate = isDate;
+exports.isEmptyArray = isEmptyArray;
+exports.isEmptyObject = isEmptyObject;
+exports.isEmptyString = isEmptyString;
+exports.isError = isError;
+exports.isFile = isFile;
+exports.isFullArray = isFullArray;
+exports.isFullObject = isFullObject;
+exports.isFullString = isFullString;
+exports.isFunction = isFunction;
+exports.isMap = isMap;
+exports.isNaNValue = isNaNValue;
+exports.isNull = isNull;
+exports.isNullOrUndefined = isNullOrUndefined;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isObjectLike = isObjectLike;
+exports.isOneOf = isOneOf;
+exports.isPlainObject = isPlainObject;
+exports.isPrimitive = isPrimitive;
+exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
+exports.isSet = isSet;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isType = isType;
+exports.isUndefined = isUndefined;
+exports.isWeakMap = isWeakMap;
+exports.isWeakSet = isWeakSet;