@takeshape/util 11.45.5 → 11.47.1

package/dist/cjs/common/value.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.value = void 0;
+function value(x) {
+    return () => x;
+}
+exports.value = value;
+exports.default = value;

package/dist/cjs/common/visit.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visitJsonPath = exports.visit = void 0;
+const isObject_js_1 = __importDefault(require("lodash/isObject.js"));
+/**
+ * Walk a tree, calling the callback for any property name matching a value in the keys array.
+ */
+function visit(tree, keys, callback) {
+    const traverse = (obj, path) => {
+        for (const [key, value] of Object.entries(obj)) {
+            if (keys.includes(key)) {
+                callback(value, [...path, key]);
+            }
+            if ((0, isObject_js_1.default)(value)) {
+                traverse(value, [...path, key]);
+            }
+        }
+    };
+    traverse(tree, []);
+}
+exports.visit = visit;
+/**
+ * Walk a tree with JSONPath, calling the callback for matching properties.
+ * Normalizes the resulting path
+ */
+function visitJsonPath(tree, jsonPaths, callback) {
+    const paths = jsonPaths.map((p) => p.split('.').slice());
+    const testPaths = (propPath) => {
+        return paths.findIndex((testPath) => {
+            const isFromRoot = testPath[0] === '$';
+            const tPath = isFromRoot ? testPath.slice(1) : testPath.slice().reverse();
+            const pPath = isFromRoot ? propPath.slice() : propPath.slice().reverse();
+            let isMatchingPath = isFromRoot ? tPath.length === pPath.length : tPath.length <= pPath.length;
+            for (const [pI, pP] of pPath.entries()) {
+                if (tPath[pI] === undefined || !isMatchingPath) {
+                    break;
+                }
+                isMatchingPath = pP === tPath[pI] || tPath[pI] === '*';
+            }
+            return isMatchingPath;
+        });
+    };
+    const traverse = (obj, path) => {
+        for (const [prop, value] of Object.entries(obj)) {
+            const propPath = [...path, prop];
+            const foundIndex = testPaths(propPath);
+            if (foundIndex > -1) {
+                callback(value, propPath, foundIndex);
+            }
+            if ((0, isObject_js_1.default)(value)) {
+                traverse(value, propPath);
+            }
+        }
+    };
+    traverse(tree, []);
+}
+exports.visitJsonPath = visitJsonPath;

package/dist/cjs/node/encryption.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decrypt = exports.encrypt = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const curry_js_1 = __importDefault(require("lodash/curry.js"));
+const CIPHER_ALGORITHM = 'aes-256-ctr';
+const IV_LENGTH = 16;
+const KEY_ENCODING = 'base64';
+const CIPHER_TEXT_ENCODING = 'base64';
+const CONTENT_ENCODING = 'utf8';
+exports.encrypt = (0, curry_js_1.default)((key, plaintext) => {
+    // Initialization Vector
+    const iv = node_crypto_1.default.randomBytes(IV_LENGTH);
+    const cipher = node_crypto_1.default.createCipheriv(CIPHER_ALGORITHM, Buffer.from(key, KEY_ENCODING), iv);
+    const cipherText = cipher.update(Buffer.from(plaintext, CONTENT_ENCODING));
+    return Buffer.concat([iv, cipherText, cipher.final()]).toString(CIPHER_TEXT_ENCODING);
+});
+exports.decrypt = (0, curry_js_1.default)((key, encrypted) => {
+    const input = Buffer.from(encrypted, CIPHER_TEXT_ENCODING);
+    if (input.length < IV_LENGTH + 1) {
+        throw new TypeError('Provided "encrypted" must decrypt to a non-empty string');
+    }
+    // Initialization Vector
+    const iv = input.slice(0, IV_LENGTH);
+    const decipher = node_crypto_1.default.createDecipheriv(CIPHER_ALGORITHM, Buffer.from(key, KEY_ENCODING), iv);
+    const cipherText = input.slice(IV_LENGTH);
+    return Buffer.concat([decipher.update(cipherText), decipher.final()]).toString(CONTENT_ENCODING);
+});

package/dist/cjs/node/gzip.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gunzip = exports.gzip = void 0;
+const node_util_1 = require("node:util");
+const node_zlib_1 = __importDefault(require("node:zlib"));
+exports.gzip = (0, node_util_1.promisify)(node_zlib_1.default.gzip);
+exports.gunzip = (0, node_util_1.promisify)(node_zlib_1.default.gunzip);

package/dist/cjs/node/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./encryption.js"), exports);
+__exportStar(require("./gzip.js"), exports);
+__exportStar(require("./search-params.js"), exports);

package/dist/cjs/node/search-params.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concatURLSearchParams = exports.toSearchParamsRecord = exports.toSearchParamsEntries = void 0;
+const node_url_1 = require("node:url");
+function toSearchParamsEntries(obj) {
+    if (obj instanceof node_url_1.URLSearchParams) {
+        return [...obj.entries()];
+    }
+    if (typeof obj === 'object' && !Array.isArray(obj)) {
+        return Object.entries(obj).map(([k, v]) => [k, v?.toString() ?? '']);
+    }
+    return [...new node_url_1.URLSearchParams(obj).entries()];
+}
+exports.toSearchParamsEntries = toSearchParamsEntries;
+function toSearchParamsRecord(obj) {
+    return Object.fromEntries(toSearchParamsEntries(obj));
+}
+exports.toSearchParamsRecord = toSearchParamsRecord;
+function concatURLSearchParams(...searchParamsInput) {
+    const entries = searchParamsInput.flatMap((item) => (item ? toSearchParamsEntries(item) : []));
+    return new node_url_1.URLSearchParams(entries);
+}
+exports.concatURLSearchParams = concatURLSearchParams;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/dist/esm/common/arrays.js

@@ -0,0 +1,33 @@
+export function arrayContainsAll(a, b) {
+    return a.every((value) => b.includes(value));
+}
+export function setIsEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    if (a.length === 0) {
+        return true;
+    }
+    const refSet = new Set(a);
+    return b.every((value) => refSet.has(value));
+}
+export function arrayStartsWith(a, b) {
+    if (a.length < b.length) {
+        return false;
+    }
+    for (let i = 0; i < b.length; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+export function isDefined(x) {
+    return x !== null && x !== undefined;
+}
+export function toArray(obj) {
+    return obj ? [obj] : [];
+}
+export function ensureArray(obj) {
+    return Array.isArray(obj) ? obj : [obj];
+}

package/dist/esm/common/assert.js

@@ -0,0 +1,5 @@
+export function assert(arg, message) {
+    if (!arg) {
+        throw new Error(message);
+    }
+}

package/dist/esm/common/async-noop.js

@@ -0,0 +1,2 @@
+import { value } from './value.js';
+export const asyncNoop = value(Promise.resolve());

package/dist/esm/common/billing.js

@@ -0,0 +1,29 @@
+import { assert } from './assert.js';
+export const DEFAULT_MIN_SCHEDULE_TRIGGER_INTERVAL = 60;
+export const DEFAULT_ENTITLEMENTS = {
+    users: 3,
+    apiRequests: 10000,
+    apiRateLimit: 5,
+    contentEntries: 500,
+    deployTargets: 1,
+    roles: 5,
+    workflows: 0,
+    locales: 2,
+    webhooks: true,
+    providers: [],
+    importFromCSV: false,
+    minScheduleTriggerInterval: DEFAULT_MIN_SCHEDULE_TRIGGER_INTERVAL,
+    bandwidth: 5,
+    apiCdn: false,
+    guards: 0
+};
+export function isStripeProductObject(product) {
+    return Boolean(product && typeof product !== 'string' && product.object === 'product' && !product.deleted);
+}
+export function getStripeProductObject(product) {
+    assert(isStripeProductObject(product), 'product is not a Stripe product object');
+    return product;
+}
+export function isStripeChargeObject(charge) {
+    return typeof charge !== 'string';
+}

package/dist/esm/common/clone.js

@@ -0,0 +1,71 @@
+import { isIterableObject } from './types.js';
+/**
+ * Clone any JSON serializable value similar to JSON.parse(JSON.stringify()) but better performance
+ */
+export function deepClone(value) {
+    if (!value) {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const { length } = value;
+        const result = new Array(length);
+        for (let i = 0; i < length; i++) {
+            result[i] = deepClone(value[i]);
+        }
+        return result;
+    }
+    if (isIterableObject(value)) {
+        const obj = value;
+        const result = {};
+        for (const key of Object.keys(obj)) {
+            const value = obj[key];
+            if (value !== undefined) {
+                result[key] = deepClone(value);
+            }
+        }
+        return result;
+    }
+    return value;
+}
+export const REMOVE = Symbol('REMOVE');
+function arrayFilter(value) {
+    return value !== REMOVE;
+}
+/**
+ * Clone any JSON serializable value and transform using a callback
+ * @param value the value to clone
+ * @param customizer a callback that is called for every key/index
+ */
+export function deepCloneWith(value, customizer) {
+    const clone = (value, key, parent) => {
+        const newValue = customizer(value, key, parent, clone);
+        if (newValue !== undefined) {
+            return newValue;
+        }
+        if (Array.isArray(value)) {
+            const { length } = value;
+            const arr = new Array(length);
+            let edited = false;
+            for (let i = 0; i < length; i++) {
+                const newValue = clone(value[i], i, value);
+                if (newValue === REMOVE) {
+                    edited = true;
+                }
+                arr[i] = newValue;
+            }
+            return edited ? arr.filter(arrayFilter) : arr;
+        }
+        if (isIterableObject(value)) {
+            const newObject = {};
+            for (const key of Object.keys(value)) {
+                const newValue = clone(value[key], key, value);
+                if (newValue !== undefined && newValue !== REMOVE) {
+                    newObject[key] = newValue;
+                }
+            }
+            return newObject;
+        }
+        return value;
+    };
+    return clone(value, undefined, undefined);
+}

package/dist/esm/common/delay.js

@@ -0,0 +1,22 @@
+export async function delay(timeout, value) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, timeout, value);
+    });
+}
+function randomInt(minimum, maximum) {
+    const co = Math.random() * (maximum - minimum + 1);
+    return Math.floor(co + minimum);
+}
+// Decorrelated jitter backoff:
+// https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/
+export async function backoff(baseDelay, maxDelay, attempt = { num: 1, lastDelay: 0 }) {
+    const msec = Math.min(maxDelay, randomInt(baseDelay, (attempt.lastDelay || baseDelay) * 3));
+    await delay(msec);
+    return {
+        num: attempt.num + 1,
+        lastDelay: msec
+    };
+}
+export async function randomDelay(minimum, maximum, value) {
+    return delay(randomInt(minimum, maximum), value);
+}

package/dist/esm/common/draftjs-templates.js

@@ -0,0 +1,122 @@
+import shortid from 'shortid';
+export const getDraftjsImage = (params) => {
+    const { captionText, creditText, alignment, size, assetId, linkUrl, linkIsExternal, depth, key, path } = params;
+    const blockKey = shortid.generate();
+    return {
+        contentBlock: {
+            key: shortid.generate(),
+            text: ' ',
+            type: 'atomic',
+            depth,
+            inlineStyleRanges: [],
+            entityRanges: [
+                {
+                    offset: 0,
+                    length: 1,
+                    key
+                }
+            ],
+            data: {}
+        },
+        entities: {
+            [key]: {
+                type: 'image',
+                mutability: 'IMMUTABLE',
+                data: {
+                    id: assetId,
+                    path,
+                    caption: {
+                        blocks: [
+                            {
+                                key: blockKey,
+                                text: captionText,
+                                type: 'unstyled',
+                                depth,
+                                inlineStyleRanges: [],
+                                entityRanges: [],
+                                data: {}
+                            }
+                        ],
+                        entityMap: {}
+                    },
+                    credit: {
+                        blocks: [
+                            {
+                                key: blockKey,
+                                text: creditText,
+                                type: 'unstyled',
+                                depth,
+                                inlineStyleRanges: [],
+                                entityRanges: [],
+                                data: {}
+                            }
+                        ],
+                        entityMap: {}
+                    },
+                    link: {
+                        url: linkUrl,
+                        external: linkIsExternal
+                    },
+                    alignment,
+                    size,
+                    contentTypeId: 'ASSET'
+                }
+            }
+        }
+    };
+};
+export const getDraftjsPullquote = (params) => {
+    const { text, depth } = params;
+    return {
+        contentBlock: {
+            key: shortid.generate(),
+            text,
+            type: 'pullquote',
+            depth,
+            inlineStyleRanges: [],
+            entityRanges: [],
+            data: {}
+        },
+        entities: {}
+    };
+};
+export const getDraftjsOembed = (params) => {
+    const { key, depth, html, width = 550, height = undefined, url = undefined, author_name = undefined, author_url = undefined, type = undefined, cache_age = undefined, provider_name = undefined, provider_url = undefined, version = undefined } = params;
+    return {
+        contentBlock: {
+            key: shortid.generate(),
+            text: ' ',
+            type: 'atomic',
+            depth,
+            inlineStyleRanges: [],
+            entityRanges: [
+                {
+                    offset: 0,
+                    length: 1,
+                    key
+                }
+            ],
+            data: {}
+        },
+        // Only html is required
+        entities: {
+            [key]: {
+                type: 'oembed',
+                mutability: 'IMMUTABLE',
+                data: {
+                    url,
+                    author_name,
+                    author_url,
+                    html,
+                    width,
+                    height,
+                    type,
+                    cache_age,
+                    provider_name,
+                    provider_url,
+                    version
+                }
+            }
+        }
+    };
+};