@flourish/sdk 4.2.2 → 5.0.0

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

@@ -1,191 +0,0 @@
-# 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

@@ -1,60 +0,0 @@
-/* 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

@@ -1,364 +0,0 @@
-'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;