@uploadcare/file-uploader 0.50.1-alpha.2

package/utils/fileTypes.js

@@ -0,0 +1,95 @@
+// @ts-check
+import { stringToArray } from './stringToArray.js';
+
+export const IMAGE_ACCEPT_LIST = [
+  'image/*',
+  'image/heif',
+  'image/heif-sequence',
+  'image/heic',
+  'image/heic-sequence',
+  'image/avif',
+  'image/avif-sequence',
+  '.heif',
+  '.heifs',
+  '.heic',
+  '.heics',
+  '.avif',
+  '.avifs',
+];
+
+/**
+ * @param {string[]} [fileTypes]
+ * @returns {string[]}
+ */
+export const mergeFileTypes = (fileTypes) => {
+  if (!fileTypes) {
+    return [];
+  }
+  return fileTypes
+    .filter((item) => typeof item === 'string')
+    .map((str) => stringToArray(str))
+    .flat();
+};
+
+/**
+ * @param {String} mimeType
+ * @param {String[]} allowedFileTypes
+ * @returns {Boolean}
+ */
+export const matchMimeType = (mimeType, allowedFileTypes) => {
+  return allowedFileTypes.some((type) => {
+    if (type.endsWith('*')) {
+      type = type.replace('*', '');
+      return mimeType.startsWith(type);
+    }
+
+    return mimeType === type;
+  });
+};
+
+/**
+ * @param {String} fileName
+ * @param {String[]} allowedFileTypes
+ * @returns {Boolean}
+ */
+export const matchExtension = (fileName, allowedFileTypes) => {
+  return allowedFileTypes.some((type) => {
+    if (!type.startsWith('.')) {
+      return false;
+    }
+
+    return fileName.toLowerCase().endsWith(type.toLowerCase());
+  });
+};
+
+/**
+ * @param {File | Blob} file
+ * @returns {Boolean}
+ */
+export const fileIsImage = (file) => {
+  let type = file?.type;
+  if (!type) {
+    return false;
+  }
+  return matchMimeType(type, IMAGE_ACCEPT_LIST);
+};
+
+/**
+ * Checks if the given data is a Blob.
+ *
+ * @param {unknown} data - The data to check.
+ * @returns {boolean} - True if the data is a Blob, false otherwise.
+ */
+export const isBlob = (data) => {
+  return typeof Blob !== 'undefined' && data instanceof Blob;
+};
+
+/**
+ * Checks if the given data is a File.
+ *
+ * @param {unknown} data - The data to check.
+ * @returns {boolean} - True if the data is a File, false otherwise.
+ */
+export const isFile = (data) => {
+  return typeof File !== 'undefined' && data instanceof File;
+};

package/utils/fileTypes.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fileTypes.test.d.ts.map

package/utils/fileTypes.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileTypes.test.d.ts","sourceRoot":"","sources":["fileTypes.test.js"],"names":[],"mappings":""}

package/utils/fileTypes.test.js

@@ -0,0 +1,89 @@
+import { expect } from '@esm-bundle/chai';
+import { mergeFileTypes, matchMimeType, fileIsImage, matchExtension, isBlob, isFile } from './fileTypes';
+
+describe('mergeFileTypes', () => {
+  it('should join input strings with comma', () => {
+    expect(mergeFileTypes(['text/html,text/plain', 'image/*,image/heic', 'text/markdown'])).to.eql([
+      'text/html',
+      'text/plain',
+      'image/*',
+      'image/heic',
+      'text/markdown',
+    ]);
+  });
+
+  it('should skip empty values', () => {
+    expect(mergeFileTypes()).to.eql([]);
+    expect(mergeFileTypes(['text/html', '', undefined, 'text/plain'])).to.eql(['text/html', 'text/plain']);
+  });
+
+  it('should trim values', () => {
+    expect(mergeFileTypes([' text/html , text/plain ', ' image/*, image/heic ', ' text/markdown '])).to.eql([
+      'text/html',
+      'text/plain',
+      'image/*',
+      'image/heic',
+      'text/markdown',
+    ]);
+  });
+});
+
+describe('matchMimeType', () => {
+  it('should return true if file type is exactly matched', () => {
+    expect(matchMimeType('image/jpeg', ['image/jpeg'])).to.be.true;
+  });
+  it('should return true if file type is wildcard matched', () => {
+    expect(matchMimeType('image/jpeg', ['image/*'])).to.be.true;
+  });
+  it('should return false if file type is not matched', () => {
+    expect(matchMimeType('text/plain', ['image/*'])).to.be.false;
+  });
+});
+
+describe('matchExtension', () => {
+  it('should return true if file extension is exactly matched', () => {
+    expect(matchExtension('image.jpeg', ['.jpeg'])).to.be.true;
+    expect(matchExtension('image.avif', ['.avif'])).to.be.true;
+  });
+  it('should return false if file extension is not matched', () => {
+    expect(matchExtension('image.jpeg', ['.png'])).to.be.false;
+    expect(matchExtension('image.avifs', ['.avif'])).to.be.false;
+  });
+  it('should be case insensitive', () => {
+    expect(matchExtension('image.PNG', ['.png'])).to.be.true;
+  });
+});
+
+describe('fileIsImage', () => {
+  it('should return true if file is image', () => {
+    const file = new File([''], 'name', { type: 'image/jpeg' });
+    expect(fileIsImage(file)).to.be.true;
+  });
+  it('should return false if file is not image', () => {
+    const file = new File([''], 'name', { type: 'text/plain' });
+    expect(fileIsImage(file)).to.be.false;
+  });
+});
+
+describe('isBlob', () => {
+  it('should return true if Blob is passed', () => {
+    expect(isBlob(new Blob(['']))).to.be.true;
+  });
+  it('should return true if File is passed', () => {
+    expect(isBlob(new File([''], 'test.txt'))).to.be.true;
+  });
+  it('should return false if something else passed', () => {
+    expect(isBlob('test')).to.be.false;
+    expect(isBlob({ uri: 'test' })).to.be.false;
+  });
+});
+describe('isFile', () => {
+  it('should return true if File is passed', () => {
+    expect(isFile(new File([''], 'test.txt'))).to.be.true;
+  });
+  it('should return false if something else passed', () => {
+    expect(isFile(new Blob(['']))).to.be.false;
+    expect(isFile('test')).to.be.false;
+    expect(isFile({ uri: 'test' })).to.be.false;
+  });
+});

package/utils/getLocaleDirection.d.ts

@@ -0,0 +1,2 @@
+export function getLocaleDirection(localeId: string): string;
+//# sourceMappingURL=getLocaleDirection.d.ts.map

package/utils/getLocaleDirection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getLocaleDirection.d.ts","sourceRoot":"","sources":["getLocaleDirection.js"],"names":[],"mappings":"AAEO,6CADK,MAAM,UAgBjB"}

package/utils/getLocaleDirection.js

@@ -0,0 +1,18 @@
+// @ts-check
+/** @param {string} localeId */
+export const getLocaleDirection = (localeId) => {
+  /**
+   * @type {typeof Intl.Locale & {
+   *   textInfo?: { direction: string };
+   *   getTextInfo?: () => { direction: string };
+   * }}
+   */
+  const locale = /** @type {any} */ (new Intl.Locale(localeId));
+  let direction = 'ltr';
+  if (typeof locale.getTextInfo === 'function' && locale.getTextInfo().direction) {
+    direction = locale.getTextInfo().direction;
+  } else if ('textInfo' in locale && locale.textInfo?.direction) {
+    direction = locale.textInfo.direction;
+  }
+  return direction;
+};

package/utils/getPluralForm.d.ts

@@ -0,0 +1,3 @@
+export function getPluralForm(locale: string, count: number): PluralForm;
+export type PluralForm = Intl.LDMLPluralRule;
+//# sourceMappingURL=getPluralForm.d.ts.map

package/utils/getPluralForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPluralForm.d.ts","sourceRoot":"","sources":["getPluralForm.js"],"names":[],"mappings":"AASO,sCAJI,MAAM,SACN,MAAM,GACJ,UAAU,CAKtB;yBAVa,KAAK,cAAc"}

package/utils/getPluralForm.js

@@ -0,0 +1,13 @@
+// @ts-check
+
+/** @typedef {Intl.LDMLPluralRule} PluralForm */
+
+/**
+ * @param {string} locale
+ * @param {number} count
+ * @returns {PluralForm}
+ */
+export const getPluralForm = (locale, count) => {
+  const pluralForm = new Intl.PluralRules(locale).select(count);
+  return pluralForm;
+};

package/utils/getPluralForm.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=getPluralForm.test.d.ts.map

package/utils/getPluralForm.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPluralForm.test.d.ts","sourceRoot":"","sources":["getPluralForm.test.js"],"names":[],"mappings":""}

package/utils/getPluralForm.test.js

@@ -0,0 +1,16 @@
+import { getPluralForm } from './getPluralForm';
+import { expect } from '@esm-bundle/chai';
+
+describe('getPluralForm', () => {
+  it('should return selected form for es-US', () => {
+    expect(getPluralForm('en-US', 1)).to.equal('one');
+    expect(getPluralForm('en-US', 2)).to.equal('other');
+  });
+
+  it('should return selected form for ru-RU', () => {
+    expect(getPluralForm('ru-RU', 1)).to.equal('one');
+    expect(getPluralForm('ru-RU', 2)).to.equal('few');
+    expect(getPluralForm('ru-RU', 5)).to.equal('many');
+    expect(getPluralForm('ru-RU', 1.5)).to.equal('other');
+  });
+});

package/utils/ifRef.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This will check if the execution environment is a short code snippet, and not the complete HTML-document
+ *
+ * @param {Function} cb
+ */
+export function ifRef(cb: Function): void;
+//# sourceMappingURL=ifRef.d.ts.map

package/utils/ifRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ifRef.d.ts","sourceRoot":"","sources":["ifRef.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,0CAGC"}

package/utils/ifRef.js

@@ -0,0 +1,9 @@
+/**
+ * This will check if the execution environment is a short code snippet, and not the complete HTML-document
+ *
+ * @param {Function} cb
+ */
+export function ifRef(cb) {
+  // @ts-ignore
+  typeof window.__IS_REF__ === 'boolean' && !!window.__IS_REF__ && cb();
+}

package/utils/isSecureTokenExpired.d.ts

@@ -0,0 +1,4 @@
+export function isSecureTokenExpired(secureToken: import('../types').SecureUploadsSignatureAndExpire, { threshold }: {
+    threshold?: number;
+}): boolean;
+//# sourceMappingURL=isSecureTokenExpired.d.ts.map

package/utils/isSecureTokenExpired.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSecureTokenExpired.d.ts","sourceRoot":"","sources":["isSecureTokenExpired.js"],"names":[],"mappings":"AAUO,kDAHI,OAAO,UAAU,EAAE,+BAA+B,iBAClD;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,WAQhC"}

package/utils/isSecureTokenExpired.js

@@ -0,0 +1,17 @@
+/** @param {number} ms */
+const msToUnixTimestamp = (ms) => Math.floor(ms / 1000);
+
+/**
+ * Check if secure token is expired. It uses a threshold of 10 seconds by default. i.e. if the token is not expired yet
+ * but will expire in the next 10 seconds, it will return false.
+ *
+ * @param {import('../types').SecureUploadsSignatureAndExpire} secureToken
+ * @param {{ threshold?: number }} options
+ */
+export const isSecureTokenExpired = (secureToken, { threshold }) => {
+  const { secureExpire } = secureToken;
+  const nowUnix = msToUnixTimestamp(Date.now());
+  const expireUnix = Number(secureExpire);
+  const thresholdUnix = msToUnixTimestamp(threshold);
+  return nowUnix + thresholdUnix >= expireUnix;
+};

package/utils/isSecureTokenExpired.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=isSecureTokenExpired.test.d.ts.map

package/utils/isSecureTokenExpired.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isSecureTokenExpired.test.d.ts","sourceRoot":"","sources":["isSecureTokenExpired.test.js"],"names":[],"mappings":""}

package/utils/isSecureTokenExpired.test.js

@@ -0,0 +1,33 @@
+import { isSecureTokenExpired } from './isSecureTokenExpired';
+import { expect } from '@esm-bundle/chai';
+import * as sinon from 'sinon';
+
+const DATE_NOW = 60 * 1000;
+const THRESHOLD = 10 * 1000;
+
+describe('isSecureTokenExpired', () => {
+  let clock;
+  beforeEach(() => {
+    clock = sinon.useFakeTimers(DATE_NOW);
+  });
+
+  afterEach(() => {
+    clock.restore();
+  });
+
+  it('should return true if the token is expired', () => {
+    expect(isSecureTokenExpired({ secureExpire: '0', secureSignature: '' }, { threshold: THRESHOLD })).to.equal(true);
+    expect(isSecureTokenExpired({ secureExpire: '59', secureSignature: '' }, { threshold: THRESHOLD })).to.equal(true);
+  });
+
+  it('should return true if the token will expire in the next 10 seconds', () => {
+    expect(isSecureTokenExpired({ secureExpire: '60', secureSignature: '' }, { threshold: THRESHOLD })).to.equal(true);
+    expect(isSecureTokenExpired({ secureExpire: '61', secureSignature: '' }, { threshold: THRESHOLD })).to.equal(true);
+    expect(isSecureTokenExpired({ secureExpire: '70', secureSignature: '' }, { threshold: THRESHOLD })).to.equal(true);
+  });
+
+  it("should return false if the token is not expired and won't expire in next 10 seconds", () => {
+    expect(isSecureTokenExpired({ secureExpire: '71', secureSignature: '' }, { threshold: THRESHOLD })).to.equal(false);
+    expect(isSecureTokenExpired({ secureExpire: '80', secureSignature: '' }, { threshold: THRESHOLD })).to.equal(false);
+  });
+});

package/utils/memoize.d.ts

@@ -0,0 +1,2 @@
+export function memoize<TArgs extends any[], TReturn extends unknown, T extends (...args: TArgs) => TReturn>(fn: T): T;
+//# sourceMappingURL=memoize.d.ts.map

package/utils/memoize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["memoize.js"],"names":[],"mappings":"AASO,uHAaN"}

package/utils/memoize.js

@@ -0,0 +1,23 @@
+// @ts-check
+
+/**
+ * @template {any[]} TArgs
+ * @template {any} TReturn
+ * @template {(...args: TArgs) => TReturn} T
+ * @param {T} fn
+ * @returns {T}
+ */
+export const memoize = (fn) => {
+  const cache = new Map();
+  return /** @type {T} */ (
+    (...args) => {
+      const key = JSON.stringify(args);
+      if (cache.has(key)) {
+        return cache.get(key);
+      }
+      const result = fn(...args);
+      cache.set(key, result);
+      return result;
+    }
+  );
+};

package/utils/memoize.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=memoize.test.d.ts.map

package/utils/memoize.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.test.d.ts","sourceRoot":"","sources":["memoize.test.js"],"names":[],"mappings":""}

package/utils/memoize.test.js

@@ -0,0 +1,38 @@
+import { expect } from '@esm-bundle/chai';
+import { memoize } from './memoize.js';
+import { spy } from 'sinon';
+
+describe('memoize', () => {
+  it('should cache result', () => {
+    let counter = 0;
+    const fn = spy(() => counter++);
+    const memoized = memoize(fn);
+    memoized();
+    memoized();
+    memoized();
+    expect(fn.callCount).to.equal(1);
+  });
+
+  it('should cache result for each set of arguments', () => {
+    const fn = spy((a, b) => {
+      return a + b;
+    });
+    const memoized = memoize(fn);
+
+    memoized(1, 2);
+    memoized(1, 2);
+    memoized(1, 2);
+    memoized(2, 3);
+    memoized(2, 3);
+    memoized(2, 3);
+    expect(fn.callCount).to.equal(2);
+  });
+
+  it('should return the same result as original function', () => {
+    const fn = (a, b) => a + b;
+    const memoized = memoize(fn);
+    expect(memoized(1, 2)).to.equal(fn(1, 2));
+    expect(memoized(2, 3)).to.equal(fn(2, 3));
+    expect(memoized(3, 4)).to.equal(fn(3, 4));
+  });
+});

package/utils/mixinClass.d.ts

@@ -0,0 +1,8 @@
+export type GConstructor<T> = new (...args: any[]) => T;
+/**
+ * This is a helper to create a class type extended with the provided set of instance properties. It's useful when there
+ * are some dynamic generated properties or native overrides in the class. We're use it to define dynamic access
+ * properties and events to subscribe to.
+ */
+export type MixinClass<Base extends GConstructor<HTMLElement>, InstanceProperties extends Record<string, any> = {}> = (new (...args: ConstructorParameters<Base>) => InstanceProperties & InstanceType<Base>) & Omit<Base, "new">;
+//# sourceMappingURL=mixinClass.d.ts.map

package/utils/mixinClass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mixinClass.d.ts","sourceRoot":"","sources":["mixinClass.js"],"names":[],"mappings":"4CAE2B,GAAG,EAAE,KAAK,CAAC;;;;;;qIAWnB,sBAAsB,IAAI,CAAC,KAAG,kBAAkB,GAAG,aAAa,IAAI,CAAC"}

package/utils/mixinClass.js

@@ -0,0 +1,18 @@
+/**
+ * @template T
+ * @typedef {new (...args: any[]) => T} GConstructor
+ */
+
+/**
+ * This is a helper to create a class type extended with the provided set of instance properties. It's useful when there
+ * are some dynamic generated properties or native overrides in the class. We're use it to define dynamic access
+ * properties and events to subscribe to.
+ *
+ * @template {GConstructor<HTMLElement>} Base
+ * @template {Record<string, any>} [InstanceProperties={}] Default is `{}`
+ * @typedef {{
+ *   new (...args: ConstructorParameters<Base>): InstanceProperties & InstanceType<Base>;
+ * } & Omit<Base, 'new'>} MixinClass
+ */
+
+export {};

package/utils/parseCdnUrl.d.ts

@@ -0,0 +1,9 @@
+export function parseCdnUrl({ url, cdnBase }: {
+    url: string;
+    cdnBase: string;
+}): {
+    uuid: any;
+    cdnUrlModifiers: any;
+    filename: any;
+} | null;
+//# sourceMappingURL=parseCdnUrl.d.ts.map

package/utils/parseCdnUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseCdnUrl.d.ts","sourceRoot":"","sources":["parseCdnUrl.js"],"names":[],"mappings":"AAIO,8CADK;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE;;;;SAgB3C"}

package/utils/parseCdnUrl.js

@@ -0,0 +1,20 @@
+const uuidRegex = /[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/i;
+const cdnUrlRegex = new RegExp(`^/?(${uuidRegex.source})(?:/(-/(?:[^/]+/)+)?([^/]*))?$`, 'i');
+
+/** @param {{ url: string; cdnBase: string }} options */
+export const parseCdnUrl = ({ url, cdnBase }) => {
+  const cdnBaseUrlObj = new URL(cdnBase);
+  const urlObj = new URL(url);
+
+  if (cdnBaseUrlObj.host !== urlObj.host) {
+    return null;
+  }
+
+  const [, uuid, cdnUrlModifiers, filename] = cdnUrlRegex.exec(urlObj.pathname);
+
+  return {
+    uuid,
+    cdnUrlModifiers: cdnUrlModifiers || '',
+    filename: filename || null,
+  };
+};

package/utils/parseCdnUrl.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parseCdnUrl.test.d.ts.map

package/utils/parseCdnUrl.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseCdnUrl.test.d.ts","sourceRoot":"","sources":["parseCdnUrl.test.js"],"names":[],"mappings":""}

package/utils/parseCdnUrl.test.js

@@ -0,0 +1,78 @@
+import { parseCdnUrl } from './parseCdnUrl';
+import { expect } from '@esm-bundle/chai';
+
+describe('parseCdnUrl', () => {
+  it('should should work', () => {
+    expect(
+      parseCdnUrl({
+        url: 'https://cdn.example.com/12345678-1234-5678-1234-567812345678/',
+        cdnBase: 'https://cdn.example.com',
+      }),
+    ).to.deep.equal({
+      uuid: '12345678-1234-5678-1234-567812345678',
+      cdnUrlModifiers: '',
+      filename: null,
+    });
+  });
+
+  it('should parse filename', () => {
+    expect(
+      parseCdnUrl({
+        url: 'https://cdn.example.com/12345678-1234-5678-1234-567812345678/bar.jpg',
+        cdnBase: 'https://cdn.example.com',
+      }),
+    ).to.deep.equal({
+      uuid: '12345678-1234-5678-1234-567812345678',
+      cdnUrlModifiers: '',
+      filename: 'bar.jpg',
+    });
+  });
+
+  it('should parse cdn url modifiers', () => {
+    expect(
+      parseCdnUrl({
+        url: 'https://cdn.example.com/12345678-1234-5678-1234-567812345678/-/foo/bar/baz.jpg',
+        cdnBase: 'https://cdn.example.com',
+      }),
+    ).to.deep.equal({
+      uuid: '12345678-1234-5678-1234-567812345678',
+      cdnUrlModifiers: '-/foo/bar/',
+      filename: 'baz.jpg',
+    });
+  });
+
+  it('should return null if cdn base is different', () => {
+    expect(
+      parseCdnUrl({
+        url: 'https://cdn.example.com/12345678-1234-5678-1234-567812345678/',
+        cdnBase: 'https://cdn2.example.com',
+      }),
+    ).to.equal(null);
+  });
+
+  it('should strip slashes from the end cdn base before comparing', () => {
+    expect(
+      parseCdnUrl({
+        url: 'https://cdn.example.com/12345678-1234-5678-1234-567812345678/',
+        cdnBase: 'https://cdn.example.com/',
+      }),
+    ).to.deep.equal({
+      uuid: '12345678-1234-5678-1234-567812345678',
+      cdnUrlModifiers: '',
+      filename: null,
+    });
+  });
+
+  it('should not compare the protocol', () => {
+    expect(
+      parseCdnUrl({
+        url: 'https://cdn.example.com/12345678-1234-5678-1234-567812345678/',
+        cdnBase: 'http://cdn.example.com',
+      }),
+    ).to.deep.equal({
+      uuid: '12345678-1234-5678-1234-567812345678',
+      cdnUrlModifiers: '',
+      filename: null,
+    });
+  });
+});

package/utils/parseShrink.d.ts

@@ -0,0 +1,5 @@
+export function parseShrink(value: any): {
+    size: number;
+    quality: number | undefined;
+};
+//# sourceMappingURL=parseShrink.d.ts.map

package/utils/parseShrink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseShrink.d.ts","sourceRoot":"","sources":["parseShrink.js"],"names":[],"mappings":"AAUO,yCAFM;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAyBzD"}

package/utils/parseShrink.js

@@ -0,0 +1,34 @@
+/** TODO parseShrink move to package @uploadcare/image-shrink */
+
+const MAX_SQUARE_SIDE = 16384;
+
+const regExpShrink = /^([0-9]+)x([0-9]+)(?:\s+(\d{1,2}|100)%)?$/i;
+
+/**
+ * @param value
+ * @returns {{ size: number; quality: number | undefined }}
+ */
+export const parseShrink = (value) => {
+  const terms = regExpShrink.exec(value?.toLocaleLowerCase()) || [];
+
+  if (!terms.length) {
+    return false;
+  }
+
+  const sizeShrink = terms[1] * terms[2];
+  const maxSize = MAX_SQUARE_SIDE * MAX_SQUARE_SIDE;
+
+  if (sizeShrink > maxSize) {
+    console.warn(
+      `Shrinked size can not be larger than ${Math.floor(maxSize / 1000 / 1000)}MP. ` +
+        `You have set ${terms[1]}x${terms[2]} (` +
+        `${Math.ceil(sizeShrink / 1000 / 100) / 10}MP).`,
+    );
+    return false;
+  }
+
+  return {
+    quality: terms[3] ? terms[3] / 100 : undefined,
+    size: sizeShrink,
+  };
+};

package/utils/parseShrink.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parseShrink.test.d.ts.map

package/utils/parseShrink.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseShrink.test.d.ts","sourceRoot":"","sources":["parseShrink.test.js"],"names":[],"mappings":""}