@uploadcare/file-uploader 0.50.1-alpha.2

package/abstract/SecureUploadsManager.js

@@ -0,0 +1,87 @@
+// @ts-check
+
+import { isSecureTokenExpired } from '../utils/isSecureTokenExpired.js';
+
+export class SecureUploadsManager {
+  /**
+   * @private
+   * @type {import('./UploaderBlock.js').UploaderBlock}
+   */
+  _block;
+  /**
+   * @private
+   * @type {import('../types').SecureUploadsSignatureAndExpire | null}
+   */
+  _secureToken = null;
+
+  /** @param {import('./UploaderBlock.js').UploaderBlock} block */
+  constructor(block) {
+    this._block = block;
+  }
+
+  /**
+   * @private
+   * @param {unknown[]} args
+   */
+  _debugPrint(...args) {
+    this._block.debugPrint('[secure-uploads]', ...args);
+  }
+
+  /** @returns {Promise<import('../types').SecureUploadsSignatureAndExpire | null>} */
+  async getSecureToken() {
+    const { secureSignature, secureExpire, secureUploadsSignatureResolver } = this._block.cfg;
+
+    if ((secureSignature || secureExpire) && secureUploadsSignatureResolver) {
+      console.warn(
+        'Both secureSignature/secureExpire and secureUploadsSignatureResolver are set. secureUploadsSignatureResolver will be used.',
+      );
+    }
+
+    if (secureUploadsSignatureResolver) {
+      if (
+        !this._secureToken ||
+        isSecureTokenExpired(this._secureToken, { threshold: this._block.cfg.secureUploadsExpireThreshold })
+      ) {
+        if (!this._secureToken) {
+          this._debugPrint('Secure signature is not set yet.');
+        } else {
+          this._debugPrint('Secure signature is expired. Resolving a new one...');
+        }
+        try {
+          const result = await secureUploadsSignatureResolver();
+          if (!result) {
+            this._debugPrint('Secure signature resolver returned nothing.');
+            this._secureToken = null;
+          } else if (!result.secureSignature || !result.secureExpire) {
+            console.error('Secure signature resolver returned an invalid result:', result);
+          } else {
+            this._debugPrint('Secure signature resolved:', result);
+            this._debugPrint(
+              'Secure signature will expire in',
+              new Date(Number(result.secureExpire) * 1000).toISOString(),
+            );
+            this._secureToken = result;
+          }
+        } catch (err) {
+          console.error('Secure signature resolving failed. Falling back to the previous one.', err);
+        }
+      }
+
+      return this._secureToken;
+    }
+
+    if (secureSignature && secureExpire) {
+      this._debugPrint('Secure signature and expire are set. Using them...', {
+        secureSignature,
+        secureExpire,
+      });
+
+      return {
+        secureSignature,
+        secureExpire,
+      };
+    }
+
+    return null;
+  }
+}

package/abstract/SolutionBlock.d.ts

@@ -0,0 +1,23 @@
+export class SolutionBlock extends Block {
+    static set template(value: any);
+    static get template(): any;
+    init$: {
+        '*commonProgress': number;
+        '*uploadList': never[];
+        '*focusedEntry': null;
+        '*uploadQueue': import("@uploadcare/upload-client").Queue;
+        '*collectionErrors': any[];
+        '*collectionState': import("../index.js").OutputCollectionState<import("../index.js").OutputCollectionStatus, "maybe-has-group"> | null;
+        '*groupInfo': import("@uploadcare/upload-client").UploadcareGroup | null;
+        '*uploadTrigger': Set<string>;
+        '*secureUploadsManager': import("./SecureUploadsManager.js").SecureUploadsManager | null;
+        '*currentActivity': null;
+        '*currentActivityParams': {};
+        '*history': never[];
+        '*historyBack': null;
+        '*closeModal': () => void;
+    };
+    _template: null;
+}
+import { Block } from './Block.js';
+//# sourceMappingURL=SolutionBlock.d.ts.map

package/abstract/SolutionBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SolutionBlock.d.ts","sourceRoot":"","sources":["SolutionBlock.js"],"names":[],"mappings":"AAIA;IAWE,gCAEC;IAED,2BAEC;IAdD;;;;;;;;;;;;;;;MAA+B;IAC/B,gBAAiB;CAclB;sBArBqB,YAAY"}

package/abstract/SolutionBlock.js

@@ -0,0 +1,23 @@
+import svgIconsSprite from '../blocks/themes/uc-basic/svg-sprite.js';
+import { Block } from './Block.js';
+import { uploaderBlockCtx } from './CTX.js';
+
+export class SolutionBlock extends Block {
+  static styleAttrs = ['uc-wgt-common'];
+  requireCtxName = true;
+  init$ = uploaderBlockCtx(this);
+  _template = null;
+
+  initCallback() {
+    super.initCallback();
+    this.a11y?.registerBlock(this);
+  }
+
+  static set template(value) {
+    this._template = svgIconsSprite + value + /** HTML */ `<slot></slot>`;
+  }
+
+  static get template() {
+    return this._template;
+  }
+}

package/abstract/TypedCollection.d.ts

@@ -0,0 +1,127 @@
+export class TypedCollection {
+    /**
+     * @param {Object} options
+     * @param {Object<string, { type: any; value: any }>} options.typedSchema
+     * @param {String[]} [options.watchList]
+     * @param {(list: string[], added: Set<any>, removed: Set<any>) => void} [options.handler]
+     * @param {String} [options.ctxName]
+     */
+    constructor(options: {
+        typedSchema: {
+            [x: string]: {
+                type: any;
+                value: any;
+            };
+        };
+        watchList?: string[] | undefined;
+        handler?: ((list: string[], added: Set<any>, removed: Set<any>) => void) | undefined;
+        ctxName?: string | undefined;
+    });
+    /**
+     * @private
+     * @type {Object<string, { type: any; value: any }>}
+     */
+    private __typedSchema;
+    /**
+     * @private
+     * @type {String}
+     */
+    private __ctxId;
+    /**
+     * @private
+     * @type {Data}
+     */
+    private __data;
+    /**
+     * @private
+     * @type {string[]}
+     */
+    private __watchList;
+    /**
+     * @private
+     * @type {Object<string, any>}
+     */
+    private __subsMap;
+    /**
+     * @private
+     * @type {Set<Function>}
+     */
+    private __propertyObservers;
+    /**
+     * @private
+     * @type {Set<(list: string[], added: Set<any>, removed: Set<any>) => void>}
+     */
+    private __collectionObservers;
+    /**
+     * @private
+     * @type {Set<string>}
+     */
+    private __items;
+    /**
+     * @private
+     * @type {Set<any>}
+     */
+    private __removed;
+    /**
+     * @private
+     * @type {Set<any>}
+     */
+    private __added;
+    /**
+     * @private
+     * @param {String} propName
+     * @param {String} ctxId
+     */
+    private __notifyObservers;
+    /** @private */
+    private __observeTimeout;
+    notify(): void;
+    /** @private */
+    private __notifyTimeout;
+    /** @param {(list: string[], added: Set<any>, removed: Set<any>) => void} handler */
+    observeCollection(handler: (list: string[], added: Set<any>, removed: Set<any>) => void): () => void;
+    /** @param {Function} handler */
+    unobserveCollection(handler: Function): void;
+    /**
+     * @param {Object<string, any>} init
+     * @returns {string}
+     */
+    add(init: {
+        [x: string]: any;
+    }): string;
+    /**
+     * @param {String} id
+     * @returns {TypedData}
+     */
+    read(id: string): TypedData;
+    /**
+     * @param {String} id
+     * @param {String} propName
+     * @returns {any}
+     */
+    readProp(id: string, propName: string): any;
+    /**
+     * @template T
+     * @param {String} id
+     * @param {String} propName
+     * @param {T} value
+     */
+    publishProp<T>(id: string, propName: string, value: T): void;
+    /** @param {String} id */
+    remove(id: string): void;
+    clearAll(): void;
+    /** @param {Function} handler */
+    observeProperties(handler: Function): () => void;
+    /** @param {Function} handler */
+    unobserveProperties(handler: Function): void;
+    /**
+     * @param {(item: TypedData) => Boolean} checkFn
+     * @returns {String[]}
+     */
+    findItems(checkFn: (item: TypedData) => boolean): string[];
+    items(): string[];
+    get size(): number;
+    destroy(): void;
+}
+import { TypedData } from './TypedData.js';
+//# sourceMappingURL=TypedCollection.d.ts.map

package/abstract/TypedCollection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedCollection.d.ts","sourceRoot":"","sources":["TypedCollection.js"],"names":[],"mappings":"AAGA;IACE;;;;;;OAMG;IACH;QAL8D,WAAW;gBAAvD,MAAM,GAAE;gBAAE,IAAI,EAAE,GAAG,CAAC;gBAAC,KAAK,EAAE,GAAG,CAAA;aAAE;;QACrB,SAAS;QAC2C,OAAO,WAAvE,MAAM,EAAE,SAAS,IAAI,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,KAAK,IAAI;QAC3C,OAAO;OAgFlC;IA7EC;;;OAGG;IACH,sBAAwC;IACxC;;;OAGG;IACH,gBAAgD;IAChD;;;OAGG;IACH,eAAgD;IAChD;;;OAGG;IACH,oBAA0C;IAC1C;;;OAGG;IACH,kBAAoC;IACpC;;;OAGG;IACH,4BAAoC;IACpC;;;OAGG;IACH,8BAAsC;IACtC;;;OAGG;IACH,gBAAwB;IACxB;;;OAGG;IACH,kBAA0B;IAC1B;;;OAGG;IACH,gBAAwB;IAIxB;;;;OAIG;IACH,0BAkBC;IAVC,eAAe;IACf,yBAQE;IAIN,eAcC;IAVC,eAAe;IACf,wBAQE;IAGJ,oFAAoF;IACpF,kCADmB,MAAM,EAAE,SAAS,IAAI,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,KAAK,IAAI,cAWvE;IAED,gCAAgC;IAChC,6CAEC;IAED;;;OAGG;IACH;YAHkB,MAAM,GAAE,GAAG;QAChB,MAAM,CAuBlB;IAED;;;OAGG;IACH,kBAFa,SAAS,CAIrB;IAED;;;;OAIG;IACH,wCAFa,GAAG,CAKf;IAED;;;;;OAKG;IACH,6DAGC;IAED,yBAAyB;IACzB,yBAMC;IAED,iBAIC;IAED,gCAAgC;IAChC,iDAMC;IAED,gCAAgC;IAChC,6CAEC;IAED;;;OAGG;IACH,0BAHkB,SAAS,eACd,QAAQ,CAWpB;IAED,kBAEC;IAED,mBAEC;IAED,gBAUC;CACF;0BAnPyB,gBAAgB"}

package/abstract/TypedCollection.js

@@ -0,0 +1,245 @@
+import { Data, UID } from '@symbiotejs/symbiote';
+import { TypedData } from './TypedData.js';
+
+export class TypedCollection {
+  /**
+   * @param {Object} options
+   * @param {Object<string, { type: any; value: any }>} options.typedSchema
+   * @param {String[]} [options.watchList]
+   * @param {(list: string[], added: Set<any>, removed: Set<any>) => void} [options.handler]
+   * @param {String} [options.ctxName]
+   */
+  constructor(options) {
+    /**
+     * @private
+     * @type {Object<string, { type: any; value: any }>}
+     */
+    this.__typedSchema = options.typedSchema;
+    /**
+     * @private
+     * @type {String}
+     */
+    this.__ctxId = options.ctxName || UID.generate();
+    /**
+     * @private
+     * @type {Data}
+     */
+    this.__data = Data.registerCtx({}, this.__ctxId);
+    /**
+     * @private
+     * @type {string[]}
+     */
+    this.__watchList = options.watchList || [];
+    /**
+     * @private
+     * @type {Object<string, any>}
+     */
+    this.__subsMap = Object.create(null);
+    /**
+     * @private
+     * @type {Set<Function>}
+     */
+    this.__propertyObservers = new Set();
+    /**
+     * @private
+     * @type {Set<(list: string[], added: Set<any>, removed: Set<any>) => void>}
+     */
+    this.__collectionObservers = new Set();
+    /**
+     * @private
+     * @type {Set<string>}
+     */
+    this.__items = new Set();
+    /**
+     * @private
+     * @type {Set<any>}
+     */
+    this.__removed = new Set();
+    /**
+     * @private
+     * @type {Set<any>}
+     */
+    this.__added = new Set();
+
+    let changeMap = Object.create(null);
+
+    /**
+     * @private
+     * @param {String} propName
+     * @param {String} ctxId
+     */
+    this.__notifyObservers = (propName, ctxId) => {
+      if (this.__observeTimeout) {
+        window.clearTimeout(this.__observeTimeout);
+      }
+      if (!changeMap[propName]) {
+        changeMap[propName] = new Set();
+      }
+      changeMap[propName].add(ctxId);
+      /** @private */
+      this.__observeTimeout = window.setTimeout(() => {
+        if (Object.keys(changeMap).length === 0) {
+          return;
+        }
+        this.__propertyObservers.forEach((handler) => {
+          handler({ ...changeMap });
+        });
+        changeMap = Object.create(null);
+      });
+    };
+  }
+
+  notify() {
+    if (this.__notifyTimeout) {
+      window.clearTimeout(this.__notifyTimeout);
+    }
+    /** @private */
+    this.__notifyTimeout = window.setTimeout(() => {
+      let added = new Set(this.__added);
+      let removed = new Set(this.__removed);
+      this.__added.clear();
+      this.__removed.clear();
+      for (const handler of this.__collectionObservers) {
+        handler?.([...this.__items], added, removed);
+      }
+    });
+  }
+
+  /** @param {(list: string[], added: Set<any>, removed: Set<any>) => void} handler */
+  observeCollection(handler) {
+    this.__collectionObservers.add(handler);
+
+    if (this.__items.size > 0) {
+      this.notify();
+    }
+
+    return () => {
+      this.unobserveCollection(handler);
+    };
+  }
+
+  /** @param {Function} handler */
+  unobserveCollection(handler) {
+    this.__collectionObservers?.delete(handler);
+  }
+
+  /**
+   * @param {Object<string, any>} init
+   * @returns {string}
+   */
+  add(init) {
+    let item = new TypedData(this.__typedSchema);
+    for (let prop in init) {
+      item.setValue(prop, init[prop]);
+    }
+    this.__items.add(item.uid);
+    this.notify();
+
+    this.__data.add(item.uid, item);
+    this.__added.add(item);
+    this.__watchList.forEach((propName) => {
+      if (!this.__subsMap[item.uid]) {
+        this.__subsMap[item.uid] = [];
+      }
+      this.__subsMap[item.uid].push(
+        item.subscribe(propName, () => {
+          this.__notifyObservers(propName, item.uid);
+        }),
+      );
+    });
+    return item.uid;
+  }
+
+  /**
+   * @param {String} id
+   * @returns {TypedData}
+   */
+  read(id) {
+    return this.__data.read(id);
+  }
+
+  /**
+   * @param {String} id
+   * @param {String} propName
+   * @returns {any}
+   */
+  readProp(id, propName) {
+    let item = this.read(id);
+    return item.getValue(propName);
+  }
+
+  /**
+   * @template T
+   * @param {String} id
+   * @param {String} propName
+   * @param {T} value
+   */
+  publishProp(id, propName, value) {
+    let item = this.read(id);
+    item.setValue(propName, value);
+  }
+
+  /** @param {String} id */
+  remove(id) {
+    this.__removed.add(this.__data.read(id));
+    this.__items.delete(id);
+    this.notify();
+    this.__data.pub(id, null);
+    delete this.__subsMap[id];
+  }
+
+  clearAll() {
+    this.__items.forEach((id) => {
+      this.remove(id);
+    });
+  }
+
+  /** @param {Function} handler */
+  observeProperties(handler) {
+    this.__propertyObservers.add(handler);
+
+    return () => {
+      this.unobserveProperties(handler);
+    };
+  }
+
+  /** @param {Function} handler */
+  unobserveProperties(handler) {
+    this.__propertyObservers?.delete(handler);
+  }
+
+  /**
+   * @param {(item: TypedData) => Boolean} checkFn
+   * @returns {String[]}
+   */
+  findItems(checkFn) {
+    let result = [];
+    this.__items.forEach((id) => {
+      let item = this.read(id);
+      if (checkFn(item)) {
+        result.push(id);
+      }
+    });
+    return result;
+  }
+
+  items() {
+    return [...this.__items];
+  }
+
+  get size() {
+    return this.__items.size;
+  }
+
+  destroy() {
+    Data.deleteCtx(this.__ctxId);
+    this.__propertyObservers = null;
+    this.__collectionObservers = null;
+    for (let id in this.__subsMap) {
+      this.__subsMap[id].forEach((sub) => {
+        sub.remove();
+      });
+      delete this.__subsMap[id];
+    }
+  }
+}

package/abstract/TypedData.d.ts

@@ -0,0 +1,47 @@
+export class TypedData {
+    /**
+     * @param {Object<string, { type: any; value: any; nullable?: Boolean }>} typedSchema
+     * @param {String} [ctxName]
+     */
+    constructor(typedSchema: {
+        [x: string]: {
+            type: any;
+            value: any;
+            nullable?: boolean;
+        };
+    }, ctxName?: string | undefined);
+    /** @private */
+    private __typedSchema;
+    /** @private */
+    private __ctxId;
+    /** @private */
+    private __schema;
+    /**
+     * @private
+     * @type {Data}
+     */
+    private __data;
+    /** @returns {String} */
+    get uid(): string;
+    /**
+     * @param {String} prop
+     * @param {any} value
+     */
+    setValue(prop: string, value: any): void;
+    /** @param {Object<string, any>} updObj */
+    setMultipleValues(updObj: {
+        [x: string]: any;
+    }): void;
+    /** @param {String} prop */
+    getValue(prop: string): any;
+    /**
+     * @param {String} prop
+     * @param {(newVal: any) => void} handler
+     */
+    subscribe(prop: string, handler: (newVal: any) => void): {
+        remove: () => void;
+        callback: Function;
+    };
+    remove(): void;
+}
+//# sourceMappingURL=TypedData.d.ts.map

package/abstract/TypedData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypedData.d.ts","sourceRoot":"","sources":["TypedData.js"],"names":[],"mappings":"AAKA;IACE;;;OAGG;IACH;YAHkB,MAAM,GAAE;YAAE,IAAI,EAAE,GAAG,CAAC;YAAC,KAAK,EAAE,GAAG,CAAC;YAAC,QAAQ,CAAC,UAAS;SAAE;qCAkBtE;IAdC,eAAe;IACf,sBAAgC;IAChC,eAAe;IACf,gBAAwC;IACxC,eAAe;IACf,iBAGM;IACN;;;OAGG;IACH,eAA2D;IAG7D,wBAAwB;IACxB,kBAEC;IAED;;;OAGG;IACH,8BAFW,GAAG,QAab;IAED,0CAA0C;IAC1C;YADmB,MAAM,GAAE,GAAG;aAK7B;IAED,2BAA2B;IAC3B,4BAMC;IAED;;;OAGG;IACH,0CAFoB,GAAG,KAAK,IAAI;;;MAI/B;IAED,eAEC;CACF"}

package/abstract/TypedData.js

@@ -0,0 +1,77 @@
+import { Data, UID } from '@symbiotejs/symbiote';
+
+const MSG_NAME = '[Typed State] Wrong property name: ';
+const MSG_TYPE = '[Typed State] Wrong property type: ';
+
+export class TypedData {
+  /**
+   * @param {Object<string, { type: any; value: any; nullable?: Boolean }>} typedSchema
+   * @param {String} [ctxName]
+   */
+  constructor(typedSchema, ctxName) {
+    /** @private */
+    this.__typedSchema = typedSchema;
+    /** @private */
+    this.__ctxId = ctxName || UID.generate();
+    /** @private */
+    this.__schema = Object.keys(typedSchema).reduce((acc, key) => {
+      acc[key] = typedSchema[key].value;
+      return acc;
+    }, {});
+    /**
+     * @private
+     * @type {Data}
+     */
+    this.__data = Data.registerCtx(this.__schema, this.__ctxId);
+  }
+
+  /** @returns {String} */
+  get uid() {
+    return this.__ctxId;
+  }
+
+  /**
+   * @param {String} prop
+   * @param {any} value
+   */
+  setValue(prop, value) {
+    if (!this.__typedSchema.hasOwnProperty(prop)) {
+      console.warn(MSG_NAME + prop);
+      return;
+    }
+    let pDesc = this.__typedSchema[prop];
+    if (value?.constructor === pDesc.type || value instanceof pDesc.type || (pDesc.nullable && value === null)) {
+      this.__data.pub(prop, value);
+      return;
+    }
+    console.warn(MSG_TYPE + prop);
+  }
+
+  /** @param {Object<string, any>} updObj */
+  setMultipleValues(updObj) {
+    for (let prop in updObj) {
+      this.setValue(prop, updObj[prop]);
+    }
+  }
+
+  /** @param {String} prop */
+  getValue(prop) {
+    if (!this.__typedSchema.hasOwnProperty(prop)) {
+      console.warn(MSG_NAME + prop);
+      return undefined;
+    }
+    return this.__data.read(prop);
+  }
+
+  /**
+   * @param {String} prop
+   * @param {(newVal: any) => void} handler
+   */
+  subscribe(prop, handler) {
+    return this.__data.sub(prop, handler);
+  }
+
+  remove() {
+    Data.deleteCtx(this.__ctxId);
+  }
+}