@takeshape/util 11.73.0 → 11.76.0

package/dist/common/__tests__/path-to-string.test.js

@@ -1,7 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { pathToString } from "../path-to-string.js";
-describe('pathToString', () => {
-    it('path with array', () => {
-        expect(pathToString(['apples', 2, 'color'])).toEqual('apples[2].color');
-    });
-});

package/dist/common/__tests__/predicate.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/common/__tests__/predicate.test.js

@@ -1,18 +0,0 @@
-import { expect, test } from 'vitest';
-import { equals, falsy, not } from "../predicate.js";
-test('equals', () => {
-    const predicate = equals('foo');
-    expect(predicate('foo')).toBe(true);
-    expect(predicate('bar')).toBe(false);
-});
-test('not', () => {
-    const predicate = not(equals('foo'));
-    expect(predicate('foo')).toBe(false);
-    expect(predicate('bar')).toBe(true);
-});
-test('falsy', () => {
-    expect(falsy('foo')).toBe(false);
-    expect(falsy(1)).toBe(false);
-    expect(falsy(0)).toBe(true);
-    expect(falsy(false)).toBe(true);
-});

package/dist/common/__tests__/search-params.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/common/__tests__/search-params.test.js

@@ -1,8 +0,0 @@
-import { expect, test } from 'vitest';
-import { concatURLSearchParams } from "../search-params.js";
-test('concatURLSearchParams - concats a variety of values with ease', () => {
-    const result = concatURLSearchParams('foo=FOO', new URLSearchParams([['bar', 'BAR']]), undefined, { baz: 'BAZ' }, [
-        ['key', 'VALUE']
-    ]);
-    expect(result.toString()).toEqual('foo=FOO&bar=BAR&baz=BAZ&key=VALUE');
-});

package/dist/common/__tests__/sets.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/common/__tests__/sets.test.js

@@ -1,13 +0,0 @@
-import { expect, test } from 'vitest';
-import { addAll, mapSet } from "../sets.js";
-test('addAll', () => {
-    const result = new Set();
-    addAll(result, ['a', 'b']);
-    addAll(result, new Set(['c']));
-    expect(result).toEqual(new Set(['a', 'b', 'c']));
-});
-test('mapSet', () => {
-    const result = new Set(['a', 'b', 'c']);
-    let i = 1;
-    expect(mapSet(result, (value) => `${value}${i++}`)).toEqual(['a1', 'b2', 'c3']);
-});

package/dist/common/__tests__/sort-object.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/common/__tests__/sort-object.test.js

@@ -1,12 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { sortObject } from "../sort-object.js";
-describe('sortObject', () => {
-    test('it works', () => {
-        expect(Object.keys(sortObject({
-            c: 1,
-            b: 1,
-            a: 1,
-            d: 1
-        }))).toEqual(['a', 'b', 'c', 'd']);
-    });
-});

package/dist/common/__tests__/strings.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/common/__tests__/strings.test.js

@@ -1,78 +0,0 @@
-import { describe, expect, it, test, vi } from 'vitest';
-import { base64Decode, base64Encode, camelCase, encodePropertyName, formatShapeName, isIntegerLike, isUuid, pascalCase } from "../strings.js";
-test('camelCase - string', () => {
-    expect(camelCase('hello world')).toBe('helloWorld');
-    expect(camelCase('hello_world')).toBe('helloWorld');
-});
-test('camelCase - array', () => {
-    expect(camelCase(['hello', 'world'])).toBe('helloWorld');
-    expect(camelCase(['hello', '_world'])).toBe('helloWorld');
-});
-test('pascalCase', () => {
-    expect(pascalCase('createPostInput')).toBe('CreatePostInput');
-    expect(pascalCase('create_post_input')).toBe('CreatePostInput');
-    expect(pascalCase(['create', 'post', 'input'])).toBe('CreatePostInput');
-    // Namespace is not preserved
-    expect(pascalCase(['create', 'TSShape', 'input'])).toBe('CreateTsShapeInput');
-});
-test('formatShapeName', () => {
-    // Same output, non-namespaced shape name
-    expect(formatShapeName(['create', 'post', 'input'], { shapeNameIndex: 1 })).toBe('CreatePostInput');
-    // Non-namespaced shape name that is more complex
-    expect(formatShapeName(['create', 'Shopify_Post', 'input'], { shapeNameIndex: 1 })).toBe('CreateShopifyPostInput');
-    // Same output, non-namespaced shape name that is more complex
-    expect(formatShapeName(['create', 'Shopify_Post', 'input'], { shapeNameIndex: 1 })).toBe('CreateShopifyPostInput');
-    // Namespace is preserved
-    expect(formatShapeName(['create', 'TSShape', 'input'], { shapeNameIndex: 1 })).toBe('CreateTSShapeInput');
-    // Namespace is preserved when casing only a shapeName
-    expect(formatShapeName(['TSShapeName'], { shapeNameIndex: 0 })).toBe('TSShapeName');
-    // No change with only a shapeName, no namespace
-    expect(formatShapeName(['ShapeName'], { shapeNameIndex: 0 })).toBe('ShapeName');
-    // Namespace is preserved when casing only a shapeName
-    expect(formatShapeName('TSShapeName')).toBe('TSShapeName');
-});
-test('isUuid', () => {
-    expect(isUuid('c7522e4f-ba4e-4526-947b-49724a071e1b')).toEqual(true);
-    expect(isUuid('bak/sql.sql')).toEqual(false);
-});
-test('isIntegerLike', () => {
-    expect(isIntegerLike(1)).toEqual(true);
-    expect(isIntegerLike('1')).toEqual(true);
-    expect(isIntegerLike('a1')).toEqual(false);
-});
-describe('base64Encode', () => {
-    it('should encode a string to base64', () => {
-        vi.mock('browser-or-node', () => ({ isBrowser: false }));
-        expect(base64Encode('Hello World!')).toBe('SGVsbG8gV29ybGQh');
-    });
-    it('should handle empty strings', () => {
-        expect(base64Encode('')).toBe('');
-    });
-});
-describe('base64Decode', () => {
-    it('should decode a base64 encoded string', () => {
-        // Mock isBrowser for consistent testing
-        // In a real browser environment, this would not be necessary
-        vi.mock('browser-or-node', () => ({ isBrowser: false }));
-        expect(base64Decode('SGVsbG8gV29ybGQh')).toBe('Hello World!');
-    });
-    it('should handle empty strings', () => {
-        expect(base64Decode('')).toBe('');
-    });
-});
-describe('encodePropertyName', () => {
-    it('should encode special characters', () => {
-        expect(encodePropertyName('hello/world')).toBe('hello%2fworld');
-        expect(encodePropertyName('hello world')).toBe('hello%20world');
-        expect(encodePropertyName('hello.world')).toBe('hello%2eworld');
-        expect(encodePropertyName('hello-world')).toBe('hello%2dworld');
-        expect(encodePropertyName('hello_world?')).toBe('hello%5fworld%3f');
-        expect(encodePropertyName('hello&world')).toBe('hello%26world');
-    });
-    it('should not encode alphanumeric characters', () => {
-        expect(encodePropertyName('helloWorld123')).toBe('helloWorld123');
-    });
-    it('should handle empty strings', () => {
-        expect(encodePropertyName('')).toBe('');
-    });
-});

package/dist/common/__tests__/takeshape-id.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/common/__tests__/takeshape-id.test.js

@@ -1,26 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { extractTakeShapeIDs, parseTakeShapeID } from "../takeshape-id.js";
-describe('parseTakeShapeID', () => {
-    test('simple example', () => {
-        expect(parseTakeShapeID('tid:rick:Character:1')).toEqual({
-            service: 'rick',
-            shapeName: 'Character',
-            id: '1'
-        });
-    });
-    test('colon in the id is allowed', () => {
-        expect(parseTakeShapeID('tid:shopify:Product:gid://shopify/Product/12345')).toEqual({
-            service: 'shopify',
-            shapeName: 'Product',
-            id: 'gid://shopify/Product/12345'
-        });
-    });
-});
-describe('extractTakeShapeIDs', () => {
-    test('simple example', () => {
-        expect(extractTakeShapeIDs('Here is a cool character:\n\ntid:rick:Character:1\n\nAnd another is tid:rick:Character:2')).toEqual(['tid:rick:Character:1', 'tid:rick:Character:2']);
-    });
-    test('colons in the id part are allowed', () => {
-        expect(extractTakeShapeIDs('Here is a nice product: tid:shopify:Product:gid://shopify/Product/12345\n\nHope you like it')).toEqual(['tid:shopify:Product:gid://shopify/Product/12345']);
-    });
-});

package/dist/common/__tests__/templates.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/common/__tests__/templates.test.js

@@ -1,220 +0,0 @@
-import { describe, expect, it, test } from 'vitest';
-import { codeTemplate, getApplyPrefix, imageTemplate, jsonTemplate, oembedTemplate } from "../templates.js";
-test('getApplyPrefix', () => {
-    const applyPrefix = getApplyPrefix('prefix-');
-    expect(applyPrefix('suffix')).toBe('prefix-suffix');
-    expect(applyPrefix('')).toBe('');
-});
-const applyPrefix = getApplyPrefix('test-');
-test('imageTemplate', () => {
-    const data = {
-        asset: {
-            _id: 'asset-id',
-            path: 'path/to/image.jpg'
-        }
-    };
-    const html = imageTemplate(applyPrefix, data);
-    expect(html).toMatchSnapshot();
-});
-test('imageTemplate - no asset', () => {
-    const data = {};
-    const html = imageTemplate(applyPrefix, data);
-    expect(html).toBe('');
-});
-test('imageTemplate - caption', () => {
-    const data = {
-        caption: 'image caption',
-        asset: {
-            _id: 'asset-id',
-            path: 'path/to/image.jpg'
-        }
-    };
-    const html = imageTemplate(applyPrefix, data);
-    expect(html).toMatchSnapshot();
-});
-test('imageTemplate - credit', () => {
-    const data = {
-        credit: 'image credit',
-        asset: {
-            _id: 'asset-id',
-            path: 'path/to/image.jpg'
-        }
-    };
-    const html = imageTemplate(applyPrefix, data);
-    expect(html).toMatchSnapshot();
-});
-test('imageTemplate - alignment', () => {
-    const data = {
-        alignment: 'left',
-        asset: {
-            _id: 'asset-id',
-            path: 'path/to/image.jpg'
-        }
-    };
-    const html = imageTemplate(applyPrefix, data);
-    expect(html).toMatchSnapshot();
-});
-test('imageTemplate - default size', () => {
-    const data = {
-        asset: {
-            _id: 'asset-id',
-            path: 'path/to/image.jpg'
-        },
-        imageParams: {
-            w: 640
-        }
-    };
-    const html = imageTemplate(applyPrefix, data);
-    expect(html).toMatchSnapshot();
-});
-test('imageTemplate - title description', () => {
-    const data = {
-        asset: {
-            _id: 'asset-id',
-            path: 'path/to/image.jpg',
-            title: 'Title',
-            description: '"Description"'
-        }
-    };
-    const html = imageTemplate(applyPrefix, data);
-    expect(html).toMatchSnapshot();
-});
-test('imageTemplate - link', () => {
-    const data = {
-        link: {
-            url: 'https://www.google.com/',
-            external: false
-        },
-        asset: {
-            _id: 'asset-id',
-            path: 'path/to/image.jpg'
-        }
-    };
-    const html = imageTemplate(applyPrefix, data);
-    expect(html).toMatchSnapshot();
-});
-test('imageTemplate - link external', () => {
-    const data = {
-        link: {
-            url: 'https://www.google.com/',
-            external: true
-        },
-        asset: {
-            _id: 'asset-id',
-            path: 'path/to/image.jpg'
-        }
-    };
-    const html = imageTemplate(applyPrefix, data);
-    expect(html).toMatchSnapshot();
-});
-test('oembedTemplate', () => {
-    const data = {
-        html: '<h1>Hello World</h1>'
-    };
-    const html = oembedTemplate(applyPrefix, data);
-    expect(html).toMatchSnapshot();
-});
-test('codeTemplate', () => {
-    const data = {
-        text: '<h1>Hello World</h1>',
-        lang: 'html'
-    };
-    const html = codeTemplate(applyPrefix, data);
-    expect(html).toMatchSnapshot();
-});
-test('codeTemplate - no language', () => {
-    const data = {
-        text: '<h1>Hello World</h1>'
-    };
-    const html = codeTemplate(applyPrefix, data);
-    expect(html).toMatchSnapshot();
-});
-test('codeTemplate - no language with all escaped characters', () => {
-    const data = {
-        text: '<script> alert("double quote"); alert(\'single quote\'); & </script>'
-    };
-    const html = codeTemplate(applyPrefix, data);
-    expect(html).toMatchSnapshot();
-});
-describe('jsonTemplate', () => {
-    it('should replace placeholders with values from context', () => {
-        const template = {
-            '{{name}}': '{{value}}'
-        };
-        const context = {
-            name: 'foo',
-            value: 'bar'
-        };
-        const result = jsonTemplate(template, context);
-        expect(result).toEqual({ foo: 'bar' });
-    });
-    it('should handle nested objects and arrays', () => {
-        const template = {
-            '{{name}}': ['{{value}}', { nested: '{{nested}}' }],
-            other: '{{other}}'
-        };
-        const context = {
-            name: 'foo',
-            value: 'bar',
-            nested: 'baz',
-            other: 'qux'
-        };
-        const result = jsonTemplate(template, context);
-        expect(result).toEqual({
-            foo: ['bar', { nested: 'baz' }],
-            other: 'qux'
-        });
-    });
-    it('should handle missing values in context', () => {
-        const template = {
-            '{{name}}': '{{value}}'
-        };
-        const context = {
-            name: 'foo'
-        };
-        const result = jsonTemplate(template, context);
-        expect(result).toEqual({ foo: '' });
-    });
-    it('should not modify non-string values', () => {
-        const template = {
-            '{{name}}': 123
-        };
-        const context = {
-            name: 'foo'
-        };
-        const result = jsonTemplate(template, context);
-        expect(result).toEqual({ foo: 123 });
-    });
-    it('should handle complex nested structures', () => {
-        const template = {
-            '{{name}}': [
-                '{{value}}',
-                {
-                    nested: {
-                        '{{deep}}': true,
-                        array: ['{{item1}}', '{{item2}}']
-                    }
-                }
-            ]
-        };
-        const context = {
-            name: 'foo',
-            value: 'bar',
-            deep: 'very',
-            item1: 'one',
-            item2: 'two'
-        };
-        const result = jsonTemplate(template, context);
-        expect(result).toEqual({
-            foo: [
-                'bar',
-                {
-                    nested: {
-                        very: true,
-                        array: ['one', 'two']
-                    }
-                }
-            ]
-        });
-    });
-});

package/dist/common/__tests__/timezone.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/common/__tests__/timezone.test.js

@@ -1,8 +0,0 @@
-import { expect, test } from 'vitest';
-import { guessTimeZone, timeZoneList } from "../timezone.js";
-test('timeZoneList', () => {
-    expect(typeof guessTimeZone()).toBe('string');
-});
-test('timeZoneList', () => {
-    expect(timeZoneList).toMatchSnapshot();
-});

package/dist/common/__tests__/types.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/common/__tests__/types.test.js

@@ -1,46 +0,0 @@
-import { expect, test } from 'vitest';
-import { getSingle, isNumericString, isPrimitive, isRecord, isScalar } from "../types.js";
-test('isRecord validates plain objects', () => {
-    expect(isRecord({ foo: 'FOO' })).toEqual(true);
-    expect(isRecord(['foo'])).toEqual(false);
-    expect(isRecord(false)).toEqual(false);
-    expect(isRecord(new Date())).toEqual(false);
-    expect(isRecord(new Boolean(true))).toEqual(false);
-    expect(isRecord(new Number(1))).toEqual(false);
-    expect(isRecord(new String('abc'))).toEqual(false);
-});
-test('isPrimitive validates primitive values', () => {
-    expect(isPrimitive(1)).toEqual(true);
-    expect(isPrimitive(1n)).toEqual(true);
-    expect(isPrimitive('foo')).toEqual(true);
-    expect(isPrimitive(true)).toEqual(true);
-    expect(isPrimitive(null)).toEqual(true);
-    expect(isPrimitive(undefined)).toEqual(true);
-    expect(isPrimitive(Symbol('foo'))).toEqual(true);
-    expect(isPrimitive({ foo: 'FOO' })).toEqual(false);
-    expect(isPrimitive(['foo'])).toEqual(false);
-});
-test('isScalar validates scalar values', () => {
-    expect(isScalar(1)).toEqual(true);
-    expect(isScalar(1n)).toEqual(true);
-    expect(isScalar('foo')).toEqual(true);
-    expect(isScalar(true)).toEqual(true);
-    expect(isScalar(null)).toEqual(false);
-    expect(isScalar(undefined)).toEqual(false);
-    expect(isScalar(Symbol('foo'))).toEqual(false);
-    expect(isScalar({ foo: 'FOO' })).toEqual(false);
-    expect(isScalar(['foo'])).toEqual(false);
-});
-test('getSingle returns a single item', () => {
-    expect(getSingle(1)).toEqual(1);
-    expect(getSingle([1, 2, 3])).toEqual(1);
-    expect(getSingle('foo')).toEqual('foo');
-    expect(getSingle(['foo', 'bar'])).toEqual('foo');
-    expect(getSingle()).toBeUndefined();
-});
-test('isNumericString validates numeric strings', () => {
-    expect(isNumericString('9')).toEqual(true);
-    expect(isNumericString('9.9')).toEqual(true);
-    expect(isNumericString('nine')).toEqual(false);
-    expect(isNumericString('nine9')).toEqual(false);
-});

package/dist/common/__tests__/unix-to-iso.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/common/__tests__/unix-to-iso.test.js

@@ -1,6 +0,0 @@
-import { expect, test } from 'vitest';
-import { unixToISO } from "../unix-to-iso.js";
-test('unixToISO', () => {
-    expect(unixToISO(1594657725)).toEqual('2020-07-13T16:28:45.000Z');
-    expect(unixToISO(0)).toEqual('1970-01-01T00:00:00.000Z');
-});

package/dist/common/__tests__/urls.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/common/__tests__/urls.test.js

@@ -1,19 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { getFileName } from "../urls.js";
-describe('getFileName', () => {
-    test('http url', () => {
-        expect(getFileName('https://example.com/path/to/file.txt')).toBe('file.txt');
-    });
-    test('http url with hash', () => {
-        expect(getFileName('https://example.com/path/to/file.txt#foo')).toBe('file.txt');
-    });
-    test('s3 url', () => {
-        expect(getFileName('s3://path/to/file.txt')).toBe('file.txt');
-    });
-    test('path', () => {
-        expect(getFileName('foo/bar/baz/file.txt')).toBe('file.txt');
-    });
-    test('filename', () => {
-        expect(getFileName('file.txt')).toBe('file.txt');
-    });
-});

package/dist/common/__tests__/value.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/common/__tests__/value.test.js

@@ -1,6 +0,0 @@
-import { expect, test } from 'vitest';
-import { value } from "../value.js";
-test('value', () => {
-    const expected = 'abc';
-    expect(value(expected)()).toBe(expected);
-});

package/dist/common/__tests__/visit.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/common/__tests__/visit.test.js

@@ -1,112 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { visit, visitJsonPath } from "../visit.js";
-test('visit - can visit deeply nested objects and arrays', () => {
-    const tree = {
-        a: {
-            b: {
-                ignore: 'me',
-                c: {
-                    d: [{ name: 'foo' }, { '@name': 'bar' }],
-                    e: {
-                        name: 'baz'
-                    }
-                }
-            }
-        }
-    };
-    const results = [];
-    visit(tree, ['name', '@name'], (val, path) => {
-        results.push([val, path]);
-    });
-    expect(results).toEqual([
-        ['foo', ['a', 'b', 'c', 'd', '0', 'name']],
-        ['bar', ['a', 'b', 'c', 'd', '1', '@name']],
-        ['baz', ['a', 'b', 'c', 'e', 'name']]
-    ]);
-});
-describe('visitJsonPath', () => {
-    const tree = {
-        a: {
-            b: {
-                c: {
-                    d: [{ name: 'foo' }, { '@name': 'kitty' }],
-                    e: {
-                        name: 'tag',
-                        id: 1
-                    }
-                }
-            }
-        },
-        b: {
-            b: {
-                c: {
-                    z: [{ name: 'bar' }, { '@name': 'puppy' }],
-                    e: {
-                        name: 'tag',
-                        id: 2
-                    }
-                }
-            }
-        },
-        c: {
-            b: {
-                c: {
-                    d: [{ name: 'baz' }, { '@name': 'bunny' }],
-                    e: {
-                        name: 'tag',
-                        id: 3
-                    }
-                }
-            },
-            d: {
-                z: {
-                    '@name': 'alsomatches'
-                }
-            }
-        }
-    };
-    test('callback called with multiple JSONPath-like paths, including wildcards', () => {
-        const results = [];
-        visitJsonPath(tree, ['c.z.*.name', 'c.d.*.@name'], (val, path, foundIndex) => {
-            results.push([val, path, foundIndex]);
-        });
-        expect(results).toEqual([
-            ['kitty', ['a', 'b', 'c', 'd', '1', '@name'], 1],
-            ['bar', ['b', 'b', 'c', 'z', '0', 'name'], 0],
-            ['bunny', ['c', 'b', 'c', 'd', '1', '@name'], 1],
-            ['alsomatches', ['c', 'd', 'z', '@name'], 1]
-        ]);
-    });
-    test('callback called three times without root-anchored paths', () => {
-        const results = [];
-        visitJsonPath(tree, ['c.d'], (val, path, foundIndex) => {
-            results.push([val, path, foundIndex]);
-        });
-        expect(results).toEqual([
-            [[{ name: 'foo' }, { '@name': 'kitty' }], ['a', 'b', 'c', 'd'], 0],
-            [[{ name: 'baz' }, { '@name': 'bunny' }], ['c', 'b', 'c', 'd'], 0],
-            [{ z: { '@name': 'alsomatches' } }, ['c', 'd'], 0]
-        ]);
-    });
-    test('callback called once with root-anchored paths', () => {
-        const results = [];
-        visitJsonPath(tree, ['$.c.d'], (val, path, foundIndex) => {
-            results.push([val, path, foundIndex]);
-        });
-        expect(results).toEqual([[{ z: { '@name': 'alsomatches' } }, ['c', 'd'], 0]]);
-    });
-    test('callback called with a short path and terminal wildcard', () => {
-        const results = [];
-        visitJsonPath(tree, ['e.*'], (val, path, foundIndex) => {
-            results.push([val, path, foundIndex]);
-        });
-        expect(results).toEqual([
-            ['tag', ['a', 'b', 'c', 'e', 'name'], 0],
-            [1, ['a', 'b', 'c', 'e', 'id'], 0],
-            ['tag', ['b', 'b', 'c', 'e', 'name'], 0],
-            [2, ['b', 'b', 'c', 'e', 'id'], 0],
-            ['tag', ['c', 'b', 'c', 'e', 'name'], 0],
-            [3, ['c', 'b', 'c', 'e', 'id'], 0]
-        ]);
-    });
-});

package/dist/node/__tests__/buffer.test.d.ts

@@ -1 +0,0 @@
-export {};