@uploadcare/file-uploader 0.50.1-alpha.2

package/utils/parseShrink.test.js

@@ -0,0 +1,26 @@
+import { parseShrink } from './parseShrink.js';
+import { expect } from '@esm-bundle/chai';
+
+describe('parseShrink', () => {
+  it('should be false', () => {
+    expect(parseShrink()).to.false;
+  });
+
+  it('should be right', () => {
+    const result = expect(parseShrink('1000x1000 100%'));
+
+    result.to.have.property('quality', 1);
+    result.to.have.property('size', 1000000);
+  });
+
+  it('should be right without quality', () => {
+    const result = expect(parseShrink('1000x1000'));
+
+    result.to.have.property('quality', undefined);
+    result.to.have.property('size', 1000000);
+  });
+
+  it('should be warn, because size shrink more max size', () => {
+    expect(parseShrink('268435456x268435456 100%')).to.false;
+  });
+});

package/utils/prettyBytes.d.ts

@@ -0,0 +1,11 @@
+export const ByteUnitEnum: Readonly<{
+    AUTO: "auto";
+    BYTE: "byte";
+    KB: "kb";
+    MB: "mb";
+    GB: "gb";
+    TB: "tb";
+    PB: "pb";
+}>;
+export function prettyBytes(bytes: number, unit?: (typeof ByteUnitEnum)[keyof typeof ByteUnitEnum]): string;
+//# sourceMappingURL=prettyBytes.d.ts.map

package/utils/prettyBytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prettyBytes.d.ts","sourceRoot":"","sources":["prettyBytes.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AAiBI,mCAJI,MAAM,SACN,CAAC,mBAAmB,CAAC,CAAC,MAAM,mBAAmB,CAAC,GAC9C,MAAM,CAmClB"}

package/utils/prettyBytes.js

@@ -0,0 +1,64 @@
+// @ts-check
+import { getPluralForm } from './getPluralForm.js';
+
+const BASE = 1000;
+
+export const ByteUnitEnum = Object.freeze({
+  AUTO: 'auto',
+  BYTE: 'byte',
+  KB: 'kb',
+  MB: 'mb',
+  GB: 'gb',
+  TB: 'tb',
+  PB: 'pb',
+});
+
+/**
+ * Round a specified number to decimal with two places. Round to larger value, because basically we use it for usage and
+ * we charge customers for 1 GB even he consumed 1 byte. Feature limits are usually specified in exact MB/GB/TB, so they
+ * will not be rounded.
+ *
+ * @param {number} number
+ * @returns {number}
+ */
+const round = (number) => Math.ceil(number * 100) / 100;
+
+/**
+ * @param {number} bytes
+ * @param {(typeof ByteUnitEnum)[keyof typeof ByteUnitEnum]} unit
+ * @returns {string}
+ */
+export const prettyBytes = (bytes, unit = ByteUnitEnum.AUTO) => {
+  const isAutoMode = unit === ByteUnitEnum.AUTO;
+
+  if (unit === ByteUnitEnum.BYTE || (isAutoMode && bytes < BASE ** 1)) {
+    // TODO: handle blocks locale
+    const pluralForm = /** @type {Extract<import('./getPluralForm').PluralForm, 'one' | 'other'>} */ (
+      getPluralForm('en-US', bytes)
+    );
+    const pluralized = {
+      one: 'byte',
+      other: 'bytes',
+    }[pluralForm];
+
+    return `${bytes} ${pluralized}`;
+  }
+
+  if (unit === ByteUnitEnum.KB || (isAutoMode && bytes < BASE ** 2)) {
+    return `${round(bytes / BASE ** 1)} KB`;
+  }
+
+  if (unit === ByteUnitEnum.MB || (isAutoMode && bytes < BASE ** 3)) {
+    return `${round(bytes / BASE ** 2)} MB`;
+  }
+
+  if (unit === ByteUnitEnum.GB || (isAutoMode && bytes < BASE ** 4)) {
+    return `${round(bytes / BASE ** 3)} GB`;
+  }
+
+  if (unit === ByteUnitEnum.TB || (isAutoMode && bytes < BASE ** 5)) {
+    return `${round(bytes / BASE ** 4)} TB`;
+  }
+
+  return `${round(bytes / BASE ** 5)} PB`;
+};

package/utils/prettyBytes.test.d.ts

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

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

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

package/utils/prettyBytes.test.js

@@ -0,0 +1,99 @@
+import { prettyBytes, ByteUnitEnum } from './prettyBytes';
+import { expect } from '@esm-bundle/chai';
+
+const EXPECTED_BASE = 1000;
+
+describe('prettyBytes', () => {
+  describe('auto unit mode', () => {
+    it('should be enabled by default', () => {
+      expect(prettyBytes(EXPECTED_BASE ** 3)).to.equal('1 GB');
+    });
+
+    it('should print bytes if passed < 1 KB', () => {
+      expect(prettyBytes(EXPECTED_BASE - 1)).to.equal(`${EXPECTED_BASE - 1} bytes`);
+    });
+
+    it('should print KB if passed >= 1 KB and < 1 MB', () => {
+      expect(prettyBytes(EXPECTED_BASE ** 1)).to.equal('1 KB');
+      expect(prettyBytes(EXPECTED_BASE ** 1 * (EXPECTED_BASE - 1))).to.equal(`${EXPECTED_BASE - 1} KB`);
+    });
+
+    it('should print MB if passed >= 1 MB and < 1 GB', () => {
+      expect(prettyBytes(EXPECTED_BASE ** 2)).to.equal('1 MB');
+      expect(prettyBytes(EXPECTED_BASE ** 2 * (EXPECTED_BASE - 1))).to.equal(`${EXPECTED_BASE - 1} MB`);
+    });
+
+    it('should print GB if passed >= 1 GB and < 1 TB', () => {
+      expect(prettyBytes(EXPECTED_BASE ** 3)).to.equal('1 GB');
+      expect(prettyBytes(EXPECTED_BASE ** 3 * (EXPECTED_BASE - 1))).to.equal(`${EXPECTED_BASE - 1} GB`);
+    });
+
+    it('should print TB if passed > 1 TB and < 1 PB', () => {
+      expect(prettyBytes(EXPECTED_BASE ** 4)).to.equal('1 TB');
+      expect(prettyBytes(EXPECTED_BASE ** 4 * (EXPECTED_BASE - 1))).to.equal(`${EXPECTED_BASE - 1} TB`);
+    });
+
+    it('should print PB if passed > 1 PB', () => {
+      expect(prettyBytes(EXPECTED_BASE ** 5)).to.equal('1 PB');
+      expect(prettyBytes(EXPECTED_BASE ** 5 * (EXPECTED_BASE - 1))).to.equal(`${EXPECTED_BASE - 1} PB`);
+      expect(prettyBytes(EXPECTED_BASE ** 5 * EXPECTED_BASE)).to.equal(`${EXPECTED_BASE} PB`);
+    });
+  });
+
+  describe('specified unit mode', () => {
+    it('should print return bytes if specified bytes unit', () => {
+      expect(prettyBytes(0, ByteUnitEnum.BYTE)).to.equal('0 bytes');
+      expect(prettyBytes(EXPECTED_BASE ** 1, ByteUnitEnum.BYTE)).to.equal(`${EXPECTED_BASE ** 1} bytes`);
+      expect(prettyBytes(EXPECTED_BASE ** 5, ByteUnitEnum.BYTE)).to.equal(`${EXPECTED_BASE ** 5} bytes`);
+    });
+
+    it('should print KB if specified KB unit', () => {
+      expect(prettyBytes(0, ByteUnitEnum.KB)).to.equal('0 KB');
+
+      expect(prettyBytes(EXPECTED_BASE ** 1 / 2, ByteUnitEnum.KB)).to.equal('0.5 KB');
+      expect(prettyBytes(EXPECTED_BASE ** 2, ByteUnitEnum.KB)).to.equal(`${EXPECTED_BASE ** 1} KB`);
+      expect(prettyBytes(EXPECTED_BASE ** 3, ByteUnitEnum.KB)).to.equal(`${EXPECTED_BASE ** 2} KB`);
+    });
+
+    it('should print MB if specified MB unit', () => {
+      expect(prettyBytes(0, ByteUnitEnum.MB)).to.equal('0 MB');
+
+      expect(prettyBytes(EXPECTED_BASE ** 2 / 2, ByteUnitEnum.MB)).to.equal('0.5 MB');
+      expect(prettyBytes(EXPECTED_BASE ** 3, ByteUnitEnum.MB)).to.equal(`${EXPECTED_BASE ** 1} MB`);
+      expect(prettyBytes(EXPECTED_BASE ** 4, ByteUnitEnum.MB)).to.equal(`${EXPECTED_BASE ** 2} MB`);
+    });
+
+    it('should print GB if specified GB unit', () => {
+      expect(prettyBytes(0, ByteUnitEnum.GB)).to.equal('0 GB');
+
+      expect(prettyBytes(EXPECTED_BASE ** 3 / 2, ByteUnitEnum.GB)).to.equal('0.5 GB');
+      expect(prettyBytes(EXPECTED_BASE ** 4, ByteUnitEnum.GB)).to.equal(`${EXPECTED_BASE ** 1} GB`);
+      expect(prettyBytes(EXPECTED_BASE ** 5, ByteUnitEnum.GB)).to.equal(`${EXPECTED_BASE ** 2} GB`);
+    });
+
+    it('should print TB if specified TB unit', () => {
+      expect(prettyBytes(0, ByteUnitEnum.TB)).to.equal('0 TB');
+
+      expect(prettyBytes(EXPECTED_BASE ** 4 / 2, ByteUnitEnum.TB)).to.equal('0.5 TB');
+      expect(prettyBytes(EXPECTED_BASE ** 5, ByteUnitEnum.TB)).to.equal(`${EXPECTED_BASE ** 1} TB`);
+      expect(prettyBytes(EXPECTED_BASE ** 6, ByteUnitEnum.TB)).to.equal(`${EXPECTED_BASE ** 2} TB`);
+    });
+
+    it('should print PB if specified PB unit', () => {
+      expect(prettyBytes(0, ByteUnitEnum.PB)).to.equal('0 PB');
+
+      expect(prettyBytes(EXPECTED_BASE ** 5 / 2, ByteUnitEnum.PB)).to.equal('0.5 PB');
+      expect(prettyBytes(EXPECTED_BASE ** 6, ByteUnitEnum.PB)).to.equal(`${EXPECTED_BASE ** 1} PB`);
+      expect(prettyBytes(EXPECTED_BASE ** 7, ByteUnitEnum.PB)).to.equal(`${EXPECTED_BASE ** 2} PB`);
+    });
+  });
+
+  describe('rounding', () => {
+    it('should round up to 2 decimal places if necessary', () => {
+      expect(prettyBytes(EXPECTED_BASE)).to.equal('1 KB');
+      expect(prettyBytes(EXPECTED_BASE * 1.5)).to.equal('1.5 KB');
+      expect(prettyBytes(EXPECTED_BASE * 1.55)).to.equal('1.55 KB');
+      expect(prettyBytes(EXPECTED_BASE * 1.555)).to.equal('1.56 KB');
+    });
+  });
+});

package/utils/stringToArray.d.ts

@@ -0,0 +1,2 @@
+export function stringToArray(str: string, delimiter?: string): string[];
+//# sourceMappingURL=stringToArray.d.ts.map

package/utils/stringToArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringToArray.d.ts","sourceRoot":"","sources":["stringToArray.js"],"names":[],"mappings":"AAIO,mCAHI,MAAM,uBACJ,MAAM,EAAE,CAQpB"}

package/utils/stringToArray.js

@@ -0,0 +1,11 @@
+/**
+ * @param {string} str
+ * @returns {string[]}
+ */
+export const stringToArray = (str, delimiter = ',') => {
+  return str
+    .trim()
+    .split(delimiter)
+    .map((part) => part.trim())
+    .filter((part) => part.length > 0);
+};

package/utils/stringToArray.test.d.ts

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

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

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

package/utils/stringToArray.test.js

@@ -0,0 +1,20 @@
+import { expect } from '@esm-bundle/chai';
+import { stringToArray } from './stringToArray.js';
+
+describe('stringToArray', () => {
+  it('should convert string to array', () => {
+    expect(stringToArray('a,b,c')).to.eql(['a', 'b', 'c']);
+  });
+
+  it('should trim surrounding spaces', () => {
+    expect(stringToArray('   a   ,   b   ,  c   ')).to.eql(['a', 'b', 'c']);
+  });
+
+  it('should trim empty values', () => {
+    expect(stringToArray(',,,a,b,c')).to.eql(['a', 'b', 'c']);
+  });
+
+  it('should accept custom delimiter', () => {
+    expect(stringToArray('a b c', ' ')).to.eql(['a', 'b', 'c']);
+  });
+});

package/utils/template-utils.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @typedef {Object} Options
+ * @property {String} [openToken='{{'] Default is `'{{'`
+ * @property {String} [closeToken='}}'] Default is `'}}'`
+ * @property {(value: String) => String} [transform=DEFAULT_TRANSFORMER] Default is `DEFAULT_TRANSFORMER`
+ */
+/**
+ * @param {String} template
+ * @param {InputData} [data={}] Default is `{}`
+ * @param {Options} [options={}] Default is `{}`
+ * @returns {String}
+ */
+export function applyTemplateData(template: string, data?: InputData | undefined, options?: Options | undefined): string;
+/**
+ * @param {String} template
+ * @returns {{ variable: string; pluralKey: string; countVariable: string }[]}
+ */
+export function getPluralObjects(template: string): {
+    variable: string;
+    pluralKey: string;
+    countVariable: string;
+}[];
+export type Options = {
+    /**
+     * Default is `'{{'`
+     */
+    openToken?: string | undefined;
+    /**
+     * Default is `'}}'`
+     */
+    closeToken?: string | undefined;
+    /**
+     * Default is `DEFAULT_TRANSFORMER`
+     */
+    transform?: ((value: string) => string) | undefined;
+};
+export type InputData = {
+    [key: string]: string | number | boolean | InputData;
+};
+//# sourceMappingURL=template-utils.d.ts.map

package/utils/template-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-utils.d.ts","sourceRoot":"","sources":["template-utils.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AAEH;;;;;GAKG;AACH,yHAQC;AAED;;;GAGG;AACH,oDAFa;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,EAAE,CAiB5E"}

package/utils/template-utils.js

@@ -0,0 +1,50 @@
+/** @typedef {{ [key: String]: String | Number | Boolean | InputData }} InputData */
+
+const DEFAULT_TRANSFORMER = (value) => value;
+const OPEN_TOKEN = '{{';
+const CLOSE_TOKEN = '}}';
+const PLURAL_PREFIX = 'plural:';
+
+/**
+ * @typedef {Object} Options
+ * @property {String} [openToken='{{'] Default is `'{{'`
+ * @property {String} [closeToken='}}'] Default is `'}}'`
+ * @property {(value: String) => String} [transform=DEFAULT_TRANSFORMER] Default is `DEFAULT_TRANSFORMER`
+ */
+
+/**
+ * @param {String} template
+ * @param {InputData} [data={}] Default is `{}`
+ * @param {Options} [options={}] Default is `{}`
+ * @returns {String}
+ */
+export function applyTemplateData(template, data, options = {}) {
+  let { openToken = OPEN_TOKEN, closeToken = CLOSE_TOKEN, transform = DEFAULT_TRANSFORMER } = options;
+
+  for (let key in data) {
+    let value = data[key]?.toString();
+    template = template.replaceAll(openToken + key + closeToken, typeof value === 'string' ? transform(value) : value);
+  }
+  return template;
+}
+
+/**
+ * @param {String} template
+ * @returns {{ variable: string; pluralKey: string; countVariable: string }[]}
+ */
+export function getPluralObjects(template) {
+  const pluralObjects = [];
+  let open = template.indexOf(OPEN_TOKEN);
+  while (open !== -1) {
+    const close = template.indexOf(CLOSE_TOKEN, open);
+    const variable = template.substring(open + 2, close);
+    if (variable.startsWith(PLURAL_PREFIX)) {
+      const keyValue = template.substring(open + 2, close).replace(PLURAL_PREFIX, '');
+      const key = keyValue.substring(0, keyValue.indexOf('('));
+      const count = keyValue.substring(keyValue.indexOf('(') + 1, keyValue.indexOf(')'));
+      pluralObjects.push({ variable, pluralKey: key, countVariable: count });
+    }
+    open = template.indexOf(OPEN_TOKEN, close);
+  }
+  return pluralObjects;
+}

package/utils/template-utils.test.d.ts

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

package/utils/template-utils.test.d.ts.map

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

package/utils/template-utils.test.js

@@ -0,0 +1,56 @@
+import { expect } from '@esm-bundle/chai';
+import { applyTemplateData, getPluralObjects } from './template-utils.js';
+
+describe('template-utils', () => {
+  describe('applyTemplateData', () => {
+    it('should return the same string if no variables passed', () => {
+      let result = applyTemplateData('Hello world!');
+      expect(result).to.equal('Hello world!');
+    });
+
+    it('should replace variables', () => {
+      let result = applyTemplateData("Hello world! My name is {{name}}. I'm {{age}} years old.", {
+        name: 'John Doe',
+        age: 12,
+      });
+      expect(result).to.equal("Hello world! My name is John Doe. I'm 12 years old.");
+    });
+
+    it('should work with variables at start/end', () => {
+      const result = applyTemplateData("{{name}} my name is. I'm {{age}}", { name: 'John Doe', age: 12 });
+      expect(result).to.equal("John Doe my name is. I'm 12");
+    });
+
+    it('should work with single variable', () => {
+      const result = applyTemplateData('{{name}}', { name: 'John Doe' });
+      expect(result).to.equal('John Doe');
+    });
+
+    it('should not replace non-defined variabled', () => {
+      let result = applyTemplateData('My name is {{name}}');
+      expect(result).to.equal('My name is {{name}}');
+    });
+
+    it('should accept `transform` option', () => {
+      let result = applyTemplateData(
+        'My name is {{name}}',
+        { name: 'John Doe' },
+        { transform: (value) => value.toUpperCase() },
+      );
+      expect(result).to.equal('My name is JOHN DOE');
+    });
+  });
+
+  describe('getPluralObjects', () => {
+    it('should return array of plural objects', () => {
+      expect(
+        getPluralObjects(
+          'Uploading {{filesCount}} {{plural:file(filesCount)}} with {{errorsCount}} {{plural:error(errorsCount)}}',
+        ),
+      ).to.deep.equal([
+        { variable: 'plural:file(filesCount)', pluralKey: 'file', countVariable: 'filesCount' },
+        { variable: 'plural:error(errorsCount)', pluralKey: 'error', countVariable: 'errorsCount' },
+      ]);
+    });
+  });
+});

package/utils/toKebabCase.d.ts

@@ -0,0 +1,3 @@
+export function toKebabCase<T extends string>(str: T): KebabCase<T>;
+export type KebabCase<T extends string> = T extends `${infer Head} ${infer Tail}` ? `${Lowercase<Head>}-${KebabCase<Tail>}` : Lowercase<T>;
+//# sourceMappingURL=toKebabCase.d.ts.map

package/utils/toKebabCase.d.ts.map

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

package/utils/toKebabCase.js

@@ -0,0 +1,15 @@
+/**
+ * @template {string} T
+ * @typedef {T extends `${infer Head} ${infer Tail}` ? `${Lowercase<Head>}-${KebabCase<Tail>}` : Lowercase<T>} KebabCase
+ */
+
+/**
+ * @template {string} T
+ * @param {T} str
+ * @returns {KebabCase<T>}
+ */
+export const toKebabCase = (str) =>
+  str
+    .match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)
+    ?.map((x) => x.toLowerCase())
+    .join('-');

package/utils/toKebabCase.test.d.ts

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

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

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

package/utils/toKebabCase.test.js

@@ -0,0 +1,11 @@
+import { expect } from '@esm-bundle/chai';
+import { toKebabCase } from './toKebabCase';
+
+describe('toKebabCase', () => {
+  it('should convert camel string to kebab', () => {
+    expect(toKebabCase('foo')).to.be.equal('foo');
+    expect(toKebabCase('foo1')).to.be.equal('foo1');
+    expect(toKebabCase('fooBar')).to.be.equal('foo-bar');
+    expect(toKebabCase('fooBar1')).to.be.equal('foo-bar1');
+  });
+});

package/utils/transparentPixelSrc.d.ts

@@ -0,0 +1,2 @@
+export const TRANSPARENT_PIXEL_SRC: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=";
+//# sourceMappingURL=transparentPixelSrc.d.ts.map

package/utils/transparentPixelSrc.d.ts.map

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

package/utils/transparentPixelSrc.js

@@ -0,0 +1,2 @@
+export const TRANSPARENT_PIXEL_SRC =
+  'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=';

package/utils/uniqueArray.d.ts

@@ -0,0 +1,2 @@
+export function uniqueArray<T>(arr: T[]): T[];
+//# sourceMappingURL=uniqueArray.d.ts.map

package/utils/uniqueArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniqueArray.d.ts","sourceRoot":"","sources":["uniqueArray.js"],"names":[],"mappings":"AAKO,8CAEN"}

package/utils/uniqueArray.js

@@ -0,0 +1,8 @@
+/**
+ * @template T
+ * @param {T[]} arr
+ * @returns {T[]}
+ */
+export const uniqueArray = (arr) => {
+  return [...new Set(arr)];
+};

package/utils/uniqueArray.test.d.ts

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

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

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

package/utils/uniqueArray.test.js

@@ -0,0 +1,8 @@
+import { expect } from '@esm-bundle/chai';
+import { uniqueArray } from './uniqueArray';
+
+describe('uniqueArray', () => {
+  it('should return deduplicated array', () => {
+    expect(uniqueArray([1, 2, 3])).to.eql([1, 2, 3]);
+  });
+});

package/utils/validators/collection/index.d.ts

@@ -0,0 +1,3 @@
+export { validateCollectionUploadError } from "./validateCollectionUploadError.js";
+export { validateMultiple } from "./validateMultiple.js";
+//# sourceMappingURL=index.d.ts.map

package/utils/validators/collection/index.d.ts.map

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

package/utils/validators/collection/index.js

@@ -0,0 +1,2 @@
+export { validateCollectionUploadError } from './validateCollectionUploadError.js';
+export { validateMultiple } from './validateMultiple.js';

package/utils/validators/collection/validateCollectionUploadError.d.ts

@@ -0,0 +1,3 @@
+/** @type {import('../../../abstract/ValidationManager.js').FuncCollectionValidator} */
+export const validateCollectionUploadError: import('../../../abstract/ValidationManager.js').FuncCollectionValidator;
+//# sourceMappingURL=validateCollectionUploadError.d.ts.map

package/utils/validators/collection/validateCollectionUploadError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateCollectionUploadError.d.ts","sourceRoot":"","sources":["validateCollectionUploadError.js"],"names":[],"mappings":"AAEA,uFAAuF;AACvF,4CADW,OAAO,wCAAwC,EAAE,uBAAuB,CAQjF"}

package/utils/validators/collection/validateCollectionUploadError.js

@@ -0,0 +1,11 @@
+// @ts-check
+
+/** @type {import('../../../abstract/ValidationManager.js').FuncCollectionValidator} */
+export const validateCollectionUploadError = (collection, api) => {
+  if (collection.failedCount > 0) {
+    return {
+      type: 'SOME_FILES_HAS_ERRORS',
+      message: api.l10n('some-files-were-not-uploaded'),
+    };
+  }
+};

package/utils/validators/collection/validateMultiple.d.ts

@@ -0,0 +1,3 @@
+/** @type {import('../../../abstract/ValidationManager.js').FuncCollectionValidator} */
+export const validateMultiple: import('../../../abstract/ValidationManager.js').FuncCollectionValidator;
+//# sourceMappingURL=validateMultiple.d.ts.map

package/utils/validators/collection/validateMultiple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateMultiple.d.ts","sourceRoot":"","sources":["validateMultiple.js"],"names":[],"mappings":"AAEA,uFAAuF;AACvF,+BADW,OAAO,wCAAwC,EAAE,uBAAuB,CAwCjF"}

package/utils/validators/collection/validateMultiple.js

@@ -0,0 +1,43 @@
+//@ts-check
+
+/** @type {import('../../../abstract/ValidationManager.js').FuncCollectionValidator} */
+export const validateMultiple = (collection, api) => {
+  const total = collection.totalCount;
+  const multipleMin = api.cfg.multiple ? api.cfg.multipleMin : 0;
+  const multipleMax = api.cfg.multiple ? api.cfg.multipleMax : 1;
+
+  if (multipleMin && total < multipleMin) {
+    const message = api.l10n('files-count-limit-error-too-few', {
+      min: multipleMin,
+      max: multipleMax,
+      total,
+    });
+
+    return {
+      type: 'TOO_FEW_FILES',
+      message,
+      payload: {
+        total,
+        min: multipleMin,
+        max: multipleMax,
+      },
+    };
+  }
+
+  if (multipleMax && total > multipleMax) {
+    const message = api.l10n('files-count-limit-error-too-many', {
+      min: multipleMin,
+      max: multipleMax,
+      total,
+    });
+    return {
+      type: 'TOO_MANY_FILES',
+      message,
+      payload: {
+        total,
+        min: multipleMin,
+        max: multipleMax,
+      },
+    };
+  }
+};

package/utils/validators/file/index.d.ts

@@ -0,0 +1,5 @@
+export { validateIsImage } from "./validateIsImage.js";
+export { validateFileType } from "./validateFileType.js";
+export { validateMaxSizeLimit } from "./validateMaxSizeLimit.js";
+export { validateUploadError } from "./validateUploadError.js";
+//# sourceMappingURL=index.d.ts.map

package/utils/validators/file/index.d.ts.map

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

package/utils/validators/file/index.js

@@ -0,0 +1,4 @@
+export { validateIsImage } from './validateIsImage.js';
+export { validateFileType } from './validateFileType.js';
+export { validateMaxSizeLimit } from './validateMaxSizeLimit.js';
+export { validateUploadError } from './validateUploadError.js';

package/utils/validators/file/validateFileType.d.ts

@@ -0,0 +1,3 @@
+/** @type {import('../../../abstract/ValidationManager.js').FuncFileValidator} */
+export const validateFileType: import('../../../abstract/ValidationManager.js').FuncFileValidator;
+//# sourceMappingURL=validateFileType.d.ts.map

package/utils/validators/file/validateFileType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateFileType.d.ts","sourceRoot":"","sources":["validateFileType.js"],"names":[],"mappings":"AAGA,iFAAiF;AACjF,+BADW,OAAO,wCAAwC,EAAE,iBAAiB,CA0B3E"}