@uploadcare/file-uploader 0.50.1-alpha.2

package/utils/validators/file/validateFileType.js

@@ -0,0 +1,30 @@
+// @ts-check
+import { IMAGE_ACCEPT_LIST, matchExtension, matchMimeType, mergeFileTypes } from '../../fileTypes.js';
+
+/** @type {import('../../../abstract/ValidationManager.js').FuncFileValidator} */
+export const validateFileType = (outputEntry, api) => {
+  const imagesOnly = api.cfg.imgOnly;
+  const accept = api.cfg.accept;
+  const allowedFileTypes = mergeFileTypes([...(imagesOnly ? IMAGE_ACCEPT_LIST : []), accept]);
+  if (!allowedFileTypes.length) return;
+
+  const mimeType = outputEntry.mimeType;
+  const fileName = outputEntry.name;
+
+  if (!mimeType || !fileName) {
+    // Skip client validation if mime type or file name are not available for some reasons
+    return;
+  }
+
+  const mimeOk = matchMimeType(mimeType, allowedFileTypes);
+  const extOk = matchExtension(fileName, allowedFileTypes);
+
+  if (!mimeOk && !extOk) {
+    // Assume file type is not allowed if both mime and ext checks fail
+    return {
+      type: 'FORBIDDEN_FILE_TYPE',
+      message: api.l10n('file-type-not-allowed'),
+      payload: { entry: outputEntry },
+    };
+  }
+};

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

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

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

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

package/utils/validators/file/validateIsImage.js

@@ -0,0 +1,25 @@
+// @ts-check
+
+/** @type {import('../../../abstract/ValidationManager.js').FuncFileValidator} */
+export const validateIsImage = (outputEntry, api) => {
+  const imagesOnly = api.cfg.imgOnly;
+  const isImage = outputEntry.isImage;
+
+  if (!imagesOnly || isImage) {
+    return;
+  }
+  if (!outputEntry.fileInfo && outputEntry.externalUrl) {
+    // skip validation for not uploaded files with external url, cause we don't know if they're images or not
+    return;
+  }
+  if (!outputEntry.fileInfo && !outputEntry.mimeType) {
+    // skip validation for not uploaded files without mime-type, cause we don't know if they're images or not
+    return;
+  }
+
+  return {
+    type: 'NOT_AN_IMAGE',
+    message: api.l10n('images-only-accepted'),
+    payload: { entry: outputEntry },
+  };
+};

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

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

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

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

package/utils/validators/file/validateMaxSizeLimit.js

@@ -0,0 +1,15 @@
+// @ts-check
+import { prettyBytes } from '../../prettyBytes.js';
+
+/** @type {import('../../../abstract/ValidationManager.js').FuncFileValidator} */
+export const validateMaxSizeLimit = (outputEntry, api) => {
+  const maxFileSize = api.cfg.maxLocalFileSizeBytes;
+  const fileSize = outputEntry.size;
+  if (maxFileSize && fileSize && fileSize > maxFileSize) {
+    return {
+      type: 'FILE_SIZE_EXCEEDED',
+      message: api.l10n('files-max-size-limit-error', { maxFileSize: prettyBytes(maxFileSize) }),
+      payload: { entry: outputEntry },
+    };
+  }
+};

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

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

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

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

package/utils/validators/file/validateUploadError.js

@@ -0,0 +1,48 @@
+// @ts-check
+import { NetworkError, UploadError } from '@uploadcare/upload-client';
+
+/** @type {import('../../../abstract/ValidationManager.js').FuncFileValidator} */
+export const validateUploadError = (outputEntry, api) => {
+  const { internalId } = outputEntry;
+
+  // @ts-expect-error Use private API that is not exposed in the types
+  const internalEntry = api._uploadCollection.read(internalId);
+
+  /** @type {unknown} */
+  const cause = internalEntry?.getValue('uploadError');
+  if (!cause) {
+    return;
+  }
+
+  if (cause instanceof UploadError) {
+    return {
+      type: 'UPLOAD_ERROR',
+      message: cause.message,
+      payload: {
+        entry: outputEntry,
+        error: cause,
+      },
+    };
+  }
+
+  if (cause instanceof NetworkError) {
+    return {
+      type: 'NETWORK_ERROR',
+      message: cause.message,
+      payload: {
+        entry: outputEntry,
+        error: cause,
+      },
+    };
+  }
+
+  const error = cause instanceof Error ? cause : new Error('Unknown error', { cause });
+  return {
+    type: 'UNKNOWN_ERROR',
+    message: error.message,
+    payload: {
+      entry: outputEntry,
+      error,
+    },
+  };
+};

package/utils/waitForAttribute.d.ts

@@ -0,0 +1,8 @@
+export function waitForAttribute({ element, attribute, onSuccess, onTimeout, timeout }: {
+    element: HTMLElement;
+    attribute: string;
+    onSuccess: (value: string) => void;
+    onTimeout: () => void;
+    timeout?: number | undefined;
+}): void;
+//# sourceMappingURL=waitForAttribute.d.ts.map

package/utils/waitForAttribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"waitForAttribute.d.ts","sourceRoot":"","sources":["waitForAttribute.js"],"names":[],"mappings":"AAWO;aAPO,WAAW;eACT,MAAM;uBACE,MAAM,KAAK,IAAI;eACvB,MAAM,IAAI;;SAmCzB"}

package/utils/waitForAttribute.js

@@ -0,0 +1,43 @@
+// @ts-check
+
+/**
+ * @param {{
+ *   element: HTMLElement;
+ *   attribute: string;
+ *   onSuccess: (value: string) => void;
+ *   onTimeout: () => void;
+ *   timeout?: number;
+ * }} options
+ */
+export const waitForAttribute = ({ element, attribute, onSuccess, onTimeout, timeout = 300 }) => {
+  const currentAttrValue = element.getAttribute(attribute);
+  if (currentAttrValue !== null) {
+    onSuccess(currentAttrValue);
+    return;
+  }
+
+  const observer = new MutationObserver((mutations) => {
+    const mutation = mutations[mutations.length - 1];
+    handleMutation(mutation);
+  });
+
+  observer.observe(element, {
+    attributes: true,
+    attributeFilter: [attribute],
+  });
+
+  const timeoutId = setTimeout(() => {
+    observer.disconnect();
+    onTimeout();
+  }, timeout);
+
+  /** @param {MutationRecord} mutation */
+  const handleMutation = (mutation) => {
+    const attrValue = element.getAttribute(attribute);
+    if (mutation.type === 'attributes' && mutation.attributeName === attribute && attrValue !== null) {
+      clearTimeout(timeoutId);
+      observer.disconnect();
+      onSuccess(attrValue);
+    }
+  };
+};

package/utils/waitForAttribute.test.d.ts

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

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

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

package/utils/waitForAttribute.test.js

@@ -0,0 +1,78 @@
+import { expect } from '@esm-bundle/chai';
+import { spy } from 'sinon';
+import { delay } from './delay';
+import { waitForAttribute } from './waitForAttribute';
+
+const TEST_ATTRIBUTE = 'test-attribute';
+
+describe('waitForAttribute', () => {
+  it('should call onTimeout callback when timeout is over', async () => {
+    const element = document.createElement('div');
+    const onSuccess = spy();
+    const onTimeout = spy();
+    waitForAttribute({
+      element,
+      attribute: TEST_ATTRIBUTE,
+      onSuccess,
+      onTimeout,
+      timeout: 10,
+    });
+    await delay(100);
+    expect(onSuccess.called).to.be.false;
+    expect(onTimeout.calledOnce).to.be.true;
+  });
+  it('should call onSuccess callback when attribute is set async', async () => {
+    const element = document.createElement('div');
+    const onSuccess = spy();
+    const onTimeout = spy();
+    waitForAttribute({
+      element,
+      attribute: TEST_ATTRIBUTE,
+      onSuccess,
+      onTimeout,
+      timeout: 10,
+    });
+    element.setAttribute(TEST_ATTRIBUTE, 'test');
+    await delay(100);
+    expect(onSuccess.calledOnce).to.be.true;
+    expect(onSuccess.getCall(0).args[0]).to.equal('test');
+    expect(onTimeout.called).to.be.false;
+  });
+  it('should call onSuccess callback when attribute is set sync', async () => {
+    const element = document.createElement('div');
+    element.setAttribute(TEST_ATTRIBUTE, 'test');
+    const onSuccess = spy();
+    const onTimeout = spy();
+    waitForAttribute({
+      element,
+      attribute: TEST_ATTRIBUTE,
+      onSuccess,
+      onTimeout,
+      timeout: 10,
+    });
+    await delay(100);
+    expect(onSuccess.calledOnce).to.be.true;
+    expect(onSuccess.getCall(0).args[0]).to.equal('test');
+    expect(onTimeout.called).to.be.false;
+  });
+
+  it('should not call onSuccess on the second attribute change', async () => {
+    const element = document.createElement('div');
+    element.setAttribute(TEST_ATTRIBUTE, 'test');
+    const onSuccess = spy();
+    const onTimeout = spy();
+    waitForAttribute({
+      element,
+      attribute: TEST_ATTRIBUTE,
+      onSuccess,
+      onTimeout,
+      timeout: 10,
+    });
+    await delay(100);
+    element.setAttribute(TEST_ATTRIBUTE, 'tes2');
+    await delay(100);
+    expect(onSuccess.calledOnce).to.be.true;
+    expect(onSuccess.getCall(0).args[0]).to.equal('test');
+    expect(onTimeout.called).to.be.false;
+  });
+});

package/utils/warnOnce.d.ts

@@ -0,0 +1,3 @@
+/** @param {string} message */
+export function warnOnce(message: string): void;
+//# sourceMappingURL=warnOnce.d.ts.map

package/utils/warnOnce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"warnOnce.d.ts","sourceRoot":"","sources":["warnOnce.js"],"names":[],"mappings":"AAEA,8BAA8B;AAC9B,kCADY,MAAM,QAQjB"}

package/utils/warnOnce.js

@@ -0,0 +1,11 @@
+const warnings = new Set();
+
+/** @param {string} message */
+export function warnOnce(message) {
+  if (warnings.has(message)) {
+    return;
+  }
+
+  warnings.add(message);
+  console.warn(message);
+}

package/utils/wildcardRegexp.d.ts

@@ -0,0 +1,2 @@
+export function wildcardRegexp(str: string, flags?: string): RegExp;
+//# sourceMappingURL=wildcardRegexp.d.ts.map

package/utils/wildcardRegexp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wildcardRegexp.d.ts","sourceRoot":"","sources":["wildcardRegexp.js"],"names":[],"mappings":"AAaO,oCAJI,MAAM,UACN,MAAM,GACJ,MAAM,CAKlB"}

package/utils/wildcardRegexp.js

@@ -0,0 +1,17 @@
+/**
+ * @param {string} str
+ * @returns {string}
+ */
+const escapeRegExp = function (str) {
+  return str.replace(/[\\-\\[]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
+};
+
+/**
+ * @param {string} str
+ * @param {string} flags
+ * @returns {RegExp}
+ */
+export const wildcardRegexp = function (str, flags = 'i') {
+  const parts = str.split('*').map(escapeRegExp);
+  return new RegExp('^' + parts.join('.+') + '$', flags);
+};

package/utils/wildcardRegexp.test.d.ts

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

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

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

package/utils/wildcardRegexp.test.js

@@ -0,0 +1,19 @@
+import { expect } from '@esm-bundle/chai';
+import { wildcardRegexp } from './wildcardRegexp';
+
+describe('wildcardRegexp', () => {
+  it('should return regexp to match wildcard', () => {
+    const regexp = wildcardRegexp('*.jpg');
+    expect(regexp).to.be.instanceOf(RegExp);
+  });
+
+  it('should work for mime types', () => {
+    expect(wildcardRegexp('*.jpg').test('test.jpg')).to.be.true;
+    expect(wildcardRegexp('image/*').test('image/jpeg')).to.be.true;
+    expect(
+      wildcardRegexp('application/vnd.openxmlformats-officedocument.*').test(
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.template',
+      ),
+    ).to.be.true;
+  });
+});