@takeshape/util 11.45.5 → 11.47.1

package/{es → dist/esm/common}/get-image-url.js

@@ -1,9 +1,4 @@
 import { getImageUrl as imageUrl } from '@takeshape/routing';
 export function getImageUrl(path, defaultImageConfig, imageBaseUrl, config) {
-  return imageUrl(path, {
-    ...defaultImageConfig,
-    ...config
-  }, {
-    baseUrl: imageBaseUrl
-  });
-}
+    return imageUrl(path, { ...defaultImageConfig, ...config }, { baseUrl: imageBaseUrl });
+}

package/dist/esm/common/highlight-code.js

@@ -0,0 +1,26 @@
+/*
+ * The intention is to move all this to the client package in the end, but right now it's here
+ * to be shared between the draftjs / mdx implementations, which span the client / server differently.
+ */
+import Prism from 'prismjs';
+import 'prismjs/components/prism-javascript.js';
+import 'prismjs/components/prism-markup.js';
+import 'prismjs/components/prism-markup-templating.js';
+import 'prismjs/components/prism-css.js';
+import 'prismjs/components/prism-bash.js';
+import 'prismjs/components/prism-django.js';
+import 'prismjs/components/prism-twig.js';
+import 'prismjs/components/prism-yaml.js';
+import 'prismjs/components/prism-graphql.js';
+import 'prismjs/components/prism-sass.js';
+import 'prismjs/components/prism-scss.js';
+import 'prismjs/components/prism-markdown.js';
+import 'prismjs/components/prism-json.js';
+import escape from 'lodash/escape.js';
+export const highlightCode = (code, lang) => {
+    if (lang) {
+        const syntax = Prism.languages[lang];
+        return Prism.highlight(code, syntax, lang);
+    }
+    return escape(code);
+};

package/dist/esm/common/http.js

@@ -0,0 +1,15 @@
+import { isBrowser } from 'browser-or-node';
+export const getBasicAuthString = (basicAuth) => {
+    let authString = '';
+    if (basicAuth.username) {
+        authString += basicAuth.username;
+    }
+    authString += ':';
+    if (basicAuth.password) {
+        authString += basicAuth.password;
+    }
+    /**
+     * Not ideal, but this is used in service-providers which is imported into both the client and the api.
+     */
+    return isBrowser ? window.btoa(authString) : Buffer.from(authString).toString('base64');
+};

package/dist/esm/common/index.js

@@ -0,0 +1,34 @@
+export * from './arrays.js';
+export * from './assert.js';
+export * from './async-noop.js';
+export * from './billing.js';
+export * from './clone.js';
+export * from './delay.js';
+export * from './draftjs-templates.js';
+export * from './draftjs.js';
+export * from './get-image-url.js';
+export * from './highlight-code.js';
+export * from './http.js';
+export * from './map.js';
+export * from './memoize.js';
+export * from './merge.js';
+export * from './mime.js';
+export * from './names.js';
+export * from './naming.js';
+export * from './path-to-string.js';
+export * from './persisted-queries.js';
+export * from './predicate.js';
+export * from './set-in.js';
+export * from './sets.js';
+export * from './sleep.js';
+export * from './sort-object.js';
+export * from './strings.js';
+export * from './templates.js';
+export * from './timezone.js';
+export * from './tracing.js';
+export * from './types.js';
+export * from './unix-to-iso.js';
+export * from './urls.js';
+export * from './validation.js';
+export * from './value.js';
+export * from './visit.js';

package/{es → dist/esm/common}/map.js

@@ -1,3 +1,3 @@
 export function mapKeysToArray(map) {
-  return Array.from(map.keys());
-}
+    return Array.from(map.keys());
+}

package/dist/esm/common/memoize.js

@@ -0,0 +1,6 @@
+import memoize from 'lodash/memoize.js';
+export function weakMemoize(fn) {
+    const memoized = memoize(fn);
+    memoized.cache = new WeakMap();
+    return memoized;
+}

package/dist/esm/common/merge.js

@@ -0,0 +1,54 @@
+import difference from 'lodash/difference.js';
+import isArray from 'lodash/isArray.js';
+import isEqual from 'lodash/isEqual.js';
+import isNull from 'lodash/isNull.js';
+import merge from 'lodash/merge.js';
+import mergeWith from 'lodash/mergeWith.js';
+import omit from 'lodash/omit.js';
+import union from 'lodash/union.js';
+/**
+ * Lodash `mergeWith` customizer to concat arrays
+ */
+const arrayConcatCustomizer = (value, srcValue) => {
+    if (isArray(value)) {
+        return value.concat(srcValue);
+    }
+};
+/**
+ * Lodash `mergeWith` loaded with a customizer that concatenates arrays for a
+ * deeper merge.
+ */
+export function mergeWithArrayConcat(object, source) {
+    return mergeWith(object, source, arrayConcatCustomizer);
+}
+/**
+ * Lodash `mergeWith` customizer to merge arrays
+ */
+const arrayMergeCustomizer = (value, srcValue) => {
+    if (isArray(value) && isArray(srcValue)) {
+        return merge(value, srcValue).filter((val) => !isNull(val));
+    }
+};
+/**
+ * Lodash `mergeWith` loaded with a customizer that merges arrays at the same
+ * object path. Array items set to `null` will be removed.
+ */
+export function mergeWithArrayMerge(object, source) {
+    return mergeWith(object, source, arrayMergeCustomizer);
+}
+export function rebaseObject(to, base, from) {
+    const fromKeys = Object.keys(from);
+    const removedKeys = difference(Object.keys(base), fromKeys);
+    const newObj = omit(to, removedKeys);
+    for (const key of fromKeys) {
+        if (!isEqual(base[key], from[key])) {
+            newObj[key] = from[key];
+        }
+    }
+    return newObj;
+}
+export function rebaseArray(to, base, from) {
+    const removed = difference(base, from);
+    const added = difference(from, base);
+    return union(difference(to, removed), added);
+}

package/dist/esm/common/mime.js

@@ -0,0 +1,60 @@
+import mime from 'mime-types';
+const compressedMimeTypes = new Set([
+    'application/atom+xml',
+    'application/javascript',
+    'application/json',
+    'application/ld+json',
+    'application/manifest+json',
+    'application/rdf+xml',
+    'application/rss+xml',
+    'application/schema+json',
+    'application/vnd.geo+json',
+    'application/vnd.ms-fontobject',
+    'application/x-font-ttf',
+    'application/x-javascript',
+    'application/x-web-app-manifest+json',
+    'application/xhtml+xml',
+    'application/xml',
+    'font/eot',
+    'font/otf',
+    'font/opentype',
+    'image/bmp',
+    'image/svg+xml',
+    'image/vnd.microsoft.icon',
+    'image/x-icon',
+    'text/cache-manifest',
+    'text/css',
+    'text/html',
+    'text/javascript',
+    'text/plain',
+    'text/vcard',
+    'text/vnd.rim.location.xloc',
+    'text/vtt',
+    'text/x-component',
+    'text/x-cross-domain-policy',
+    'text/xml'
+]);
+// Application/octetstream
+const DEFAULT_TYPE = mime.lookup('bin');
+/**
+ * Gets the content type of the file, based on it's extension.
+ * @param  {String} src Path to file fow which content type should be evaluated.
+ * @return {String}     Returns string with content type and charset.
+ */
+export function contentType(src) {
+    let type = (mime.lookup(src) || DEFAULT_TYPE).replace('-', '');
+    const charset = mime.charset(type);
+    if (charset) {
+        type += `; charset=${charset}`;
+    }
+    return type;
+}
+/**
+ * Determines whether we should compress based on file extension
+ * @param  {String} src Path to file fow which content type should be evaluated.
+ * @return {Boolean}    Returns true if we should compress
+ */
+export function shouldCompress(src) {
+    const mimeType = mime.lookup(src);
+    return Boolean(mimeType && compressedMimeTypes.has(mimeType));
+}

package/dist/esm/common/names.js

@@ -0,0 +1,9 @@
+export function getUnusedName(names, desiredName) {
+    let number = 2;
+    let candidate = desiredName;
+    while (names.has(candidate)) {
+        candidate = `${desiredName}${number}`;
+        number++;
+    }
+    return candidate;
+}

package/dist/esm/common/naming.js

@@ -0,0 +1,54 @@
+import camelCase from 'lodash/camelCase.js';
+import kebabCase from 'lodash/kebabCase.js';
+export function prefixName(config, params, name) {
+    const { withVariant, withRegion, separator } = config;
+    const { appName, stage: { env, variant }, region } = params;
+    const parts = [appName, env];
+    if (withVariant && env !== 'prod' && variant) {
+        parts.push(variant);
+    }
+    if (withRegion) {
+        if (!region) {
+            throw new Error('Cannot provide a region prefix without a region in context');
+        }
+        parts.push(region);
+    }
+    if (name === '*') {
+        parts.push(name);
+    }
+    else if (config.case === 'kebabCase') {
+        parts.push(kebabCase(name));
+    }
+    else if (config.case === 'camelCase') {
+        parts.push(camelCase(name));
+    }
+    else {
+        parts.push(name);
+    }
+    return parts.join(separator);
+}
+export function dynamoTableName(params, name) {
+    return prefixName({ withVariant: true, withRegion: false, separator: '--' }, params, name);
+}
+export const variantResourceName = prefixName.bind(null, {
+    withVariant: true,
+    withRegion: false,
+    separator: '--',
+    case: 'kebabCase'
+});
+export const sharedResourceName = prefixName.bind(null, {
+    withVariant: false,
+    withRegion: false,
+    separator: '--',
+    case: 'kebabCase'
+});
+export function variantBucketName(params, name) {
+    return prefixName({ withVariant: true, withRegion: true, separator: '--' }, params, name);
+}
+export function sharedBucketName(params, name) {
+    return prefixName({ withVariant: false, withRegion: true, separator: '--' }, params, name);
+}
+export const sharedTopicName = sharedResourceName;
+export function keyName(params, name) {
+    return prefixName({ withVariant: true, withRegion: false, separator: '--' }, params, name);
+}

package/dist/esm/common/path-to-string.js

@@ -0,0 +1,6 @@
+export const pathToString = (array) => {
+    return array.reduce((string, item) => {
+        const prefix = string === '' ? '' : '.';
+        return string + (Number.isNaN(Number(item)) ? prefix + item : `[${item}]`);
+    }, '');
+};

package/{es → dist/esm/common}/persisted-queries.js

@@ -1 +1 @@
-export const PERSISTED_QUERY_NOT_FOUND_CODE = 'PERSISTED_QUERY_NOT_FOUND';
+export const PERSISTED_QUERY_NOT_FOUND_CODE = 'PERSISTED_QUERY_NOT_FOUND';

package/{es → dist/esm/common}/predicate.js

@@ -1,9 +1,9 @@
 export function not(predicate) {
-  return value => !predicate(value);
+    return (value) => !predicate(value);
 }
 export function equals(a) {
-  return b => a === b;
+    return (b) => a === b;
 }
 export function falsy(obj) {
-  return !obj;
-}
+    return !obj;
+}

package/dist/esm/common/set-in.js

@@ -0,0 +1,7 @@
+import clone from 'lodash/fp/clone.js';
+import curry from 'lodash/fp/curry.js';
+import setWith from 'lodash/fp/setWith.js';
+/**
+ * Same as lodash/set but does not mutate the arguments
+ */
+export const setIn = curry((obj, path, value) => setWith(clone, path, value, clone(obj)));

package/dist/esm/common/sets.js

@@ -0,0 +1,14 @@
+export function addAll(set, iterable) {
+    for (const value of iterable) {
+        set.add(value);
+    }
+    return set;
+}
+export function mapSet(set, fn) {
+    const result = new Array(set.size);
+    let i = 0;
+    for (const value of set) {
+        result[i++] = fn(value);
+    }
+    return result;
+}

package/dist/esm/common/sleep.js

@@ -0,0 +1,5 @@
+export async function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

package/dist/esm/common/sort-object.js

@@ -0,0 +1,12 @@
+/**
+ * Object key order is not guarenteed. This can be useful
+ * but should not be depended upon.
+ */
+export const sortObject = (obj) => {
+    // Convert object to array of key-value pairs
+    const arr = Object.entries(obj);
+    // Sort array by key
+    arr.sort(([key1], [key2]) => key1.localeCompare(key2));
+    // Convert array back to object
+    return Object.fromEntries(arr);
+};

package/dist/esm/common/strings.js

@@ -0,0 +1,60 @@
+import { isBrowser } from 'browser-or-node';
+import _camelCase from 'lodash/camelCase.js';
+import isEmpty from 'lodash/isEmpty.js';
+import isString from 'lodash/isString.js';
+import upperFirst from 'lodash/upperFirst.js';
+import { ensureArray } from './arrays.js';
+export const camelCase = _camelCase;
+export function formatShapeName(str, options) {
+    const strings = ensureArray(str);
+    const shapeNameIndex = options?.shapeNameIndex ?? 0;
+    const shapeName = strings.at(shapeNameIndex);
+    // If the shapeNameIndex is incorrect, behave as normal
+    if (!shapeName) {
+        throw new Error(`Could not find a ShapeName at index '${shapeNameIndex}'`);
+    }
+    const prefix = strings.slice(0, Math.max(shapeNameIndex, 0));
+    const suffix = strings.slice(shapeNameIndex + 1);
+    let arr = [];
+    if (prefix) {
+        arr = [...arr, pascalCase(prefix)];
+    }
+    if (shapeName.length > 2 && shapeName.startsWith('TS') && shapeName.charAt(2) === shapeName.charAt(2).toUpperCase()) {
+        // Built-in shape, prefixed with `TS`
+        arr = [...arr, shapeName];
+    }
+    else {
+        arr = [...arr, pascalCase(shapeName)];
+    }
+    if (suffix) {
+        arr = [...arr, pascalCase(suffix)];
+    }
+    return arr.join('');
+}
+/**
+ * Optional config triggers a namespace-preserving behavior for built-in shapes starting with `TS`.
+ */
+export function pascalCase(str) {
+    return upperFirst(camelCase(str));
+}
+export function isUuid(str) {
+    return Boolean(/\w{8,}(-\w{4,}){3,}-\w{12,}/.exec(str));
+}
+export function isEmptyString(str) {
+    return isString(str) && isEmpty(str);
+}
+export function isIntegerLike(value) {
+    if (typeof value === 'number') {
+        return true;
+    }
+    return /^\d+$/.test(value);
+}
+export function encodePropertyName(value) {
+    return value.replace(/[^A-Za-z0-9]/g, (c) => `%${c.charCodeAt(0).toString(16)}`);
+}
+export function base64Encode(str) {
+    return isBrowser ? window.btoa(str) : Buffer.from(str).toString('base64');
+}
+export function base64Decode(str) {
+    return isBrowser ? window.atob(str) : Buffer.from(str, 'base64').toString();
+}

package/dist/esm/common/templates.js

@@ -0,0 +1,95 @@
+import { getImageUrl } from '@takeshape/routing';
+/*
+ * The intention is to move all this to the client package in the end, but right now it's here
+ * to be shared between the draftjs / mdx implementations, which span the client / server differently.
+ */
+import classnames from 'classnames';
+import escape from 'lodash/escape.js';
+import { highlightCode } from './highlight-code.js';
+import { isRecord } from './types.js';
+export function getApplyPrefix(prefix) {
+    return (className) => (className ? prefix + className : '');
+}
+export function attrs(obj) {
+    const attrStrings = [];
+    const attrNames = Object.keys(obj);
+    attrNames.sort();
+    for (const attrName of attrNames) {
+        const value = obj[attrName];
+        if (value) {
+            attrStrings.push(`${attrName}="${escape(value)}"`);
+        }
+    }
+    return attrStrings.length ? ` ${attrStrings.join(' ')}` : '';
+}
+export function imageTemplate(applyPrefix, data) {
+    const { caption, credit, alignment, size, asset, imageParams } = data;
+    if (!asset) {
+        return '';
+    }
+    const imageUrl = getImageUrl(asset.path, imageParams);
+    let figCaption = '';
+    if (caption || credit) {
+        const htmlCaption = caption ? `<span class="${applyPrefix('caption')}">${caption}</span>` : '';
+        const htmlCredit = credit ? `<span class="${applyPrefix('credit')}">${credit}</span>` : '';
+        figCaption = `<figcaption>${htmlCaption} ${htmlCredit}</figcaption>`;
+    }
+    const classes = classnames(applyPrefix(alignment), applyPrefix(size));
+    const classAttr = classes ? ` class="${classes}"` : '';
+    const imgAttrs = attrs({
+        alt: asset.description,
+        title: asset.title
+    });
+    let image = `<img${imgAttrs} src="${imageUrl}"/>`;
+    if (data.link?.url) {
+        const target = data.link.external ? ' target="blank" rel="noopener noreferrer"' : '';
+        image = `<a href="${data.link.url}"${target}>${image}</a>`;
+    }
+    return `<figure${classAttr}>${image}${figCaption}</figure>`;
+}
+function renderMdx(tag, attributes, data, children) {
+    const tagWithAttributes = `${tag} ${attributes.map((attr) => `${attr}="${escape(data[attr])}"`).join(' ')}`;
+    if (children) {
+        return `<${tagWithAttributes}>
+${children.replace(/[\n\r]+$/, '')}
+</${tag}>`;
+    }
+    return `<${tagWithAttributes}/>`;
+}
+export function imageTemplateMdx(applyPrefix, data) {
+    return renderMdx(applyPrefix('Image'), ['id', 'caption', 'credit', 'link', 'linkisexternal', 'alignment', 'size', 'src'], data);
+}
+export function oembedTemplate(applyPrefix, data) {
+    return `<div class="${applyPrefix('oembed')}">${data.html}</div>`;
+}
+export function oembedTemplateMdx(applyPrefix, data) {
+    return renderMdx(applyPrefix('Oembed'), ['url', 'author_name', 'author_url', 'width', 'height', 'type', 'cache_age', 'provider_name', 'version'], data, data.html);
+}
+export function codeTemplate(applyPrefix, data) {
+    const { text, lang } = data;
+    const code = highlightCode(text, lang);
+    const langClass = lang ? ` class="${applyPrefix(`language-${lang}`)}"` : '';
+    return `<pre><code${langClass}>${code}</code></pre>`;
+}
+export function jsonTemplate(template, context) {
+    const renderTemplate = (template) => {
+        return template.replace(/{{(\w+)}}/g, (_, name) => context[name] ?? '');
+    };
+    const transform = (obj) => {
+        if (Array.isArray(obj)) {
+            return obj.map(transform);
+        }
+        if (isRecord(obj)) {
+            const result = {};
+            for (const key of Object.keys(obj)) {
+                result[renderTemplate(key)] = transform(obj[key]);
+            }
+            return result;
+        }
+        if (typeof obj === 'string') {
+            return renderTemplate(obj);
+        }
+        return obj;
+    };
+    return transform(template);
+}