@uploadcare/file-uploader 0.50.1-alpha.2

package/abstract/buildOutputCollectionState.js

@@ -0,0 +1,136 @@
+// @ts-check
+
+import { memoize } from '../utils/memoize.js';
+import { warnOnce } from '../utils/warnOnce.js';
+
+/** @param {string} warning */
+function createAsyncAssertWrapper(warning) {
+  let isAsync = false;
+  setTimeout(() => {
+    isAsync = true;
+  }, 0);
+
+  /**
+   * @template {any[]} TArgs
+   * @template {any} TReturn
+   * @template {(...args: TArgs) => TReturn} T
+   * @param {T} fn
+   * @returns {T}
+   */
+  const withAssert = (fn) => {
+    return /** @type {T} */ (
+      (...args) => {
+        if (isAsync) {
+          warnOnce(warning);
+        }
+        return fn(...args);
+      }
+    );
+  };
+
+  return withAssert;
+}
+
+/**
+ * @template {import('../index.js').OutputCollectionStatus} TCollectionStatus
+ * @template {import('../index.js').GroupFlag} [TGroupFlag='maybe-has-group'] Default is `'maybe-has-group'`
+ * @param {import('./UploaderBlock.js').UploaderBlock} uploaderBlock
+ * @returns {import('../index.js').OutputCollectionState<TCollectionStatus, TGroupFlag>}
+ */
+export function buildOutputCollectionState(uploaderBlock) {
+  const getters = {
+    /** @returns {number} */
+    progress: () => {
+      return uploaderBlock.$['*commonProgress'];
+    },
+    /** @returns {ReturnType<import('../types').OutputErrorFile>[]} */
+    errors: () => {
+      return uploaderBlock.$['*collectionErrors'];
+    },
+
+    /** @returns {import('@uploadcare/upload-client').UploadcareGroup | null} */
+    group: () => {
+      return uploaderBlock.$['*groupInfo'];
+    },
+
+    totalCount: () => {
+      return uploaderBlock.uploadCollection.size;
+    },
+
+    failedCount: () => {
+      return state.failedEntries.length;
+    },
+
+    successCount: () => {
+      return state.successEntries.length;
+    },
+
+    uploadingCount: () => {
+      return state.uploadingEntries.length;
+    },
+
+    status: () => {
+      const status = state.isFailed ? 'failed' : state.isUploading ? 'uploading' : state.isSuccess ? 'success' : 'idle';
+      return /** @type {TCollectionStatus} */ (status);
+    },
+
+    isSuccess: () => {
+      return (
+        state.allEntries.length > 0 &&
+        state.errors.length === 0 &&
+        state.successEntries.length === state.allEntries.length
+      );
+    },
+
+    isUploading: () => {
+      return state.allEntries.some((entry) => entry.status === 'uploading');
+    },
+
+    isFailed: () => {
+      return state.errors.length > 0 || state.failedEntries.length > 0;
+    },
+
+    allEntries: () => {
+      return uploaderBlock.getOutputData();
+    },
+
+    successEntries: () => {
+      return state.allEntries.filter((entry) => entry.status === 'success');
+    },
+
+    failedEntries: () => {
+      return state.allEntries.filter((entry) => entry.status === 'failed');
+    },
+
+    uploadingEntries: () => {
+      return state.allEntries.filter((entry) => entry.status === 'uploading');
+    },
+
+    idleEntries: () => {
+      return state.allEntries.filter((entry) => entry.status === 'idle');
+    },
+  };
+
+  const state = /** @type {import('../index.js').OutputCollectionState<TCollectionStatus, TGroupFlag>} */ (
+    /** @type {unknown} */ ({})
+  );
+  const withAssert = createAsyncAssertWrapper(
+    "You're trying to access the OutputCollectionState asynchronously. " +
+      'In this case, the data you retrieve will be newer than it was when the ' +
+      'OutputCollectionState was created or when the event was dispatched. If you want ' +
+      'to retain the state at a specific moment in time, you should use the spread operator ' +
+      'like this: `{...outputCollectionState}` or `{...e.detail}`',
+  );
+
+  for (const [key, value] of Object.entries(getters)) {
+    const name = /** @type {keyof typeof getters} */ (key);
+    const getter = /** @type {(typeof getters)[name]} */ (value);
+    const wrapped = memoize(withAssert(getter));
+    Object.defineProperty(state, name, {
+      get: wrapped,
+      enumerable: true,
+    });
+  }
+
+  return state;
+}

package/abstract/connectBlocksFrom.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {String} url Blocks pack url
+ * @param {Boolean} [register] Register connected package, if it not registered yet
+ * @returns {Promise<import('../index.js')>}
+ */
+export function connectBlocksFrom(url: string, register?: boolean | undefined): Promise<typeof import("../index.js")>;
+export const UC_WINDOW_KEY: "UC";
+//# sourceMappingURL=connectBlocksFrom.d.ts.map

package/abstract/connectBlocksFrom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectBlocksFrom.d.ts","sourceRoot":"","sources":["connectBlocksFrom.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,gFAFa,qCAA8B,CA0B1C;AA/BD,iCAAkC"}

package/abstract/connectBlocksFrom.js

@@ -0,0 +1,34 @@
+import { registerBlocks } from './registerBlocks.js';
+
+export const UC_WINDOW_KEY = 'UC';
+
+/**
+ * @param {String} url Blocks pack url
+ * @param {Boolean} [register] Register connected package, if it not registered yet
+ * @returns {Promise<import('../index.js')>}
+ */
+export async function connectBlocksFrom(url, register = false) {
+  return new Promise((resolve, reject) => {
+    if (typeof document !== 'object') {
+      resolve(null);
+      return;
+    }
+    if (typeof window === 'object' && window[UC_WINDOW_KEY]) {
+      resolve(window[UC_WINDOW_KEY]);
+      return;
+    }
+    let script = document.createElement('script');
+    script.async = true;
+    script.src = url;
+    script.onerror = () => {
+      reject();
+    };
+    script.onload = () => {
+      /** @type {import('../index.js')} */
+      let blocks = window[UC_WINDOW_KEY];
+      register && registerBlocks(blocks);
+      resolve(blocks);
+    };
+    document.head.appendChild(script);
+  });
+}

package/abstract/l10nProcessor.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @template {import('./Block.js').Block} T
+ * @param {DocumentFragment} fr
+ * @param {T} fnCtx
+ */
+export function l10nProcessor<T extends import("./Block.js").Block>(fr: DocumentFragment, fnCtx: T): void;
+//# sourceMappingURL=l10nProcessor.d.ts.map

package/abstract/l10nProcessor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l10nProcessor.d.ts","sourceRoot":"","sources":["l10nProcessor.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,wEAHW,gBAAgB,kBAyE1B"}

package/abstract/l10nProcessor.js

@@ -0,0 +1,80 @@
+// @ts-check
+
+import { localeStateKey } from './LocaleManager.js';
+
+/**
+ * @template {import('./Block.js').Block} T
+ * @param {DocumentFragment} fr
+ * @param {T} fnCtx
+ */
+export function l10nProcessor(fr, fnCtx) {
+  [...fr.querySelectorAll('[l10n]')].forEach((el) => {
+    let key = el.getAttribute('l10n');
+    if (!key) {
+      return;
+    }
+    let elProp = 'textContent';
+    let useAttribute = false;
+    if (key.includes(':')) {
+      const arr = key.split(':');
+      elProp = arr[0];
+      key = arr[1];
+      if (elProp.startsWith('@')) {
+        elProp = elProp.slice(1);
+        useAttribute = true;
+      }
+    }
+
+    // Check if the key is present in the local context
+    const localCtxKey = key;
+    if (fnCtx.has(localCtxKey)) {
+      fnCtx.sub(localCtxKey, (mappedKey) => {
+        if (!mappedKey) {
+          return;
+        }
+        // Store the subscription in a temporary map to be able to unsubscribe later
+        if (!fnCtx.l10nProcessorSubs.has(localCtxKey)) {
+          fnCtx.l10nProcessorSubs.set(localCtxKey, new Set());
+        }
+        const keySubs = fnCtx.l10nProcessorSubs.get(localCtxKey);
+        keySubs?.forEach(
+          /** @param {{ remove: () => void }} sub */
+          (sub) => {
+            sub.remove();
+            keySubs.delete(sub);
+            fnCtx.allSubs.delete(sub);
+          },
+        );
+        // We don't need the leading * in the key because we use the key as a local context key relative to the global state
+        const nodeStateKey = localeStateKey(mappedKey).replace('*', '');
+        // If the key is not present in the node context, add it
+        if (!fnCtx.nodeCtx.has(nodeStateKey)) {
+          fnCtx.nodeCtx.add(nodeStateKey, mappedKey);
+        }
+        // Subscribe on the global l10n key change
+        const sub = fnCtx.nodeCtx.sub(nodeStateKey, () => {
+          el[/** @type {'textContent'} */ (elProp)] = fnCtx.l10n(mappedKey);
+        });
+        keySubs?.add(sub);
+        // Store the subscription in the global context to make able Symbiote to unsubscribe it on destroy
+        fnCtx.allSubs.add(sub);
+        el.removeAttribute('l10n');
+      });
+    }
+
+    // Otherwise, assume the key is in the global context
+    const stateKey = localeStateKey(key);
+    if (!fnCtx.has(stateKey)) {
+      fnCtx.add(stateKey, '');
+    }
+    fnCtx.sub(stateKey, () => {
+      key = /** @type {string} */ (key);
+      if (useAttribute) {
+        el.setAttribute(elProp, fnCtx.l10n(key));
+      } else {
+        el[/** @type {'textContent'} */ (elProp)] = fnCtx.l10n(key);
+      }
+    });
+    el.removeAttribute('l10n');
+  });
+}

package/abstract/localeRegistry.d.ts

@@ -0,0 +1,5 @@
+export function defineLocale(localeName: string, definitionOrResolver: LocaleDefinition | LocaleDefinitionResolver): void;
+export function resolveLocaleDefinition(localeName: string): Promise<LocaleDefinition>;
+export type LocaleDefinition = Record<string, string>;
+export type LocaleDefinitionResolver = () => Promise<LocaleDefinition>;
+//# sourceMappingURL=localeRegistry.d.ts.map

package/abstract/localeRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localeRegistry.d.ts","sourceRoot":"","sources":["localeRegistry.js"],"names":[],"mappings":"AAoCO,yCAHI,MAAM,wBACN,gBAAgB,GAAG,wBAAwB,QAQrD;AAMM,oDAHI,MAAM,GACJ,QAAQ,gBAAgB,CAAC,CAcrC;+BAnDa,OAAO,MAAM,EAAE,MAAM,CAAC;uCACtB,MAAM,QAAQ,gBAAgB,CAAC"}

package/abstract/localeRegistry.js

@@ -0,0 +1,63 @@
+// @ts-check
+
+import { default as en } from '../locales/file-uploader/en.js';
+
+/** @type {Map<string, LocaleDefinition>} */
+const localeRegistry = new Map();
+/** @type {Map<string, LocaleDefinitionResolver>} */
+const localeResolvers = new Map();
+
+/** @typedef {Record<string, string>} LocaleDefinition */
+/** @typedef {() => Promise<LocaleDefinition>} LocaleDefinitionResolver */
+
+/**
+ * @param {string} localeName
+ * @param {LocaleDefinition} definition
+ */
+const defineLocaleSync = (localeName, definition) => {
+  if (localeRegistry.has(localeName)) {
+    console.log(`Locale ${localeName} is already defined. Overwriting...`);
+  }
+
+  localeRegistry.set(localeName, { ...en, ...definition });
+};
+
+/**
+ * @param {string} localeName
+ * @param {LocaleDefinitionResolver} definitionResolver
+ */
+const defineLocaleAsync = (localeName, definitionResolver) => {
+  localeResolvers.set(localeName, definitionResolver);
+};
+
+/**
+ * @param {string} localeName
+ * @param {LocaleDefinition | LocaleDefinitionResolver} definitionOrResolver
+ */
+export const defineLocale = (localeName, definitionOrResolver) => {
+  if (typeof definitionOrResolver === 'function') {
+    defineLocaleAsync(localeName, definitionOrResolver);
+  } else {
+    defineLocaleSync(localeName, definitionOrResolver);
+  }
+};
+
+/**
+ * @param {string} localeName
+ * @returns {Promise<LocaleDefinition>}
+ */
+export const resolveLocaleDefinition = async (localeName) => {
+  if (!localeRegistry.has(localeName)) {
+    if (!localeResolvers.has(localeName)) {
+      throw new Error(`Locale ${localeName} is not defined`);
+    }
+
+    const definitionResolver = /** @type {LocaleDefinitionResolver} */ (localeResolvers.get(localeName));
+    const definition = await definitionResolver();
+    defineLocaleSync(localeName, definition);
+  }
+
+  return /** @type {LocaleDefinition} */ (localeRegistry.get(localeName));
+};
+
+defineLocale('en', en);

package/abstract/registerBlocks.d.ts

@@ -0,0 +1,5 @@
+/** @param {Object<string, any>} blockExports */
+export function registerBlocks(blockExports: {
+    [x: string]: any;
+}): void;
+//# sourceMappingURL=registerBlocks.d.ts.map

package/abstract/registerBlocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registerBlocks.d.ts","sourceRoot":"","sources":["registerBlocks.js"],"names":[],"mappings":"AAAA,gDAAgD;AAChD;QADmB,MAAM,GAAE,GAAG;SA4B7B"}

package/abstract/registerBlocks.js

@@ -0,0 +1,31 @@
+/** @param {Object<string, any>} blockExports */
+export function registerBlocks(blockExports) {
+  for (let blockName in blockExports) {
+    let tagName = [...blockName].reduce((name, char) => {
+      if (char.toUpperCase() === char) {
+        char = '-' + char.toLowerCase();
+      }
+      return (name += char);
+    }, '');
+    if (tagName.startsWith('-')) {
+      tagName = tagName.replace('-', '');
+    }
+
+    let currentTagName = '';
+    if (!tagName.startsWith('uc-')) {
+      currentTagName = addPrefix('uc-', tagName);
+    }
+
+    let legacyTagName = '';
+    if (!tagName.startsWith('lr-')) {
+      legacyTagName = addPrefix('lr-', tagName);
+    }
+
+    if (blockExports[blockName].reg) {
+      blockExports[blockName].reg(currentTagName);
+      blockExports[blockName].reg(legacyTagName, true);
+    }
+  }
+}
+
+const addPrefix = (prefix, name) => prefix + name;

package/abstract/sharedConfigKey.d.ts

@@ -0,0 +1,2 @@
+export function sharedConfigKey<T extends keyof import("../types").ConfigType>(key: T): `*cfg/${T}`;
+//# sourceMappingURL=sharedConfigKey.d.ts.map

package/abstract/sharedConfigKey.d.ts.map

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

package/abstract/sharedConfigKey.js

@@ -0,0 +1,8 @@
+// @ts-check
+
+/**
+ * @template {keyof import('../types').ConfigType} T
+ * @param {T} key
+ * @returns {`*cfg/${T}`}
+ */
+export const sharedConfigKey = (key) => `*cfg/${key}`;

package/abstract/uploadEntrySchema.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @typedef {Object} UploadEntry
+ * @property {File} file
+ * @property {String} externalUrl
+ * @property {String} fileName
+ * @property {number} fileSize
+ * @property {number} lastModified
+ * @property {number} uploadProgress
+ * @property {String} uuid
+ * @property {Boolean} isImage
+ * @property {String} mimeType
+ * @property {String} ctxName
+ * @property {String} cdnUrl
+ * @property {String} cdnUrlModifiers
+ * @property {UploadcareFile} fileInfo
+ * @property {Boolean} isUploading
+ * @property {String} thumbUrl
+ * @property {Boolean} silent
+ * @property {({
+ *   type: import('..').OutputFileErrorType | import('..').OutputCollectionErrorType;
+ *   message: string;
+ * } & Record<string, unknown>)[]} errors
+ * @property {Error | null} uploadError
+ * @property {string | null} fullPath
+ * @property {import('@uploadcare/upload-client').Metadata | null} metadata
+ * @property {boolean} isRemoved
+ */
+/**
+ * @template {keyof UploadEntry} K
+ * @type {Record<K, { type: Function; value: any; nullable?: Boolean }>}
+ */
+export const uploadEntrySchema: Record<K, {
+    type: Function;
+    value: any;
+    nullable?: boolean;
+}>;
+export type UploadEntry = {
+    file: File;
+    externalUrl: string;
+    fileName: string;
+    fileSize: number;
+    lastModified: number;
+    uploadProgress: number;
+    uuid: string;
+    isImage: boolean;
+    mimeType: string;
+    ctxName: string;
+    cdnUrl: string;
+    cdnUrlModifiers: string;
+    fileInfo: UploadcareFile;
+    isUploading: boolean;
+    thumbUrl: string;
+    silent: boolean;
+    errors: ({
+        type: import('..').OutputFileErrorType | import('..').OutputCollectionErrorType;
+        message: string;
+    } & Record<string, unknown>)[];
+    uploadError: Error | null;
+    fullPath: string | null;
+    metadata: import('@uploadcare/upload-client').Metadata | null;
+    isRemoved: boolean;
+};
+import { UploadcareFile } from '@uploadcare/upload-client';
+//# sourceMappingURL=uploadEntrySchema.d.ts.map

package/abstract/uploadEntrySchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadEntrySchema.d.ts","sourceRoot":"","sources":["uploadEntrySchema.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;GAGG;AACH,gCAFU,OAAO,CAAC,EAAE;IAAE,IAAI,WAAW;IAAC,KAAK,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,UAAS;CAAE,CAAC,CAwGpE;;UApIW,IAAI;;;cAGJ,MAAM;kBACN,MAAM;oBACN,MAAM;;;;;;;cAON,cAAc;;;;YAId,CAAC;QACd,IAAQ,EAAE,OAAO,IAAI,EAAE,mBAAmB,GAAG,OAAO,IAAI,EAAE,yBAAyB,CAAC;QACpF,OAAW,EAAE,MAAM,CAAC;KACjB,GAAG,OAAO,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE;iBACnB,KAAK,GAAG,IAAI;cACZ,MAAM,GAAG,IAAI;cACb,OAAO,2BAA2B,EAAE,QAAQ,GAAG,IAAI;eACnD,OAAO;;+BA3BU,2BAA2B"}

package/abstract/uploadEntrySchema.js

@@ -0,0 +1,138 @@
+// @ts-check
+import { UploadcareFile } from '@uploadcare/upload-client';
+
+/**
+ * @typedef {Object} UploadEntry
+ * @property {File} file
+ * @property {String} externalUrl
+ * @property {String} fileName
+ * @property {number} fileSize
+ * @property {number} lastModified
+ * @property {number} uploadProgress
+ * @property {String} uuid
+ * @property {Boolean} isImage
+ * @property {String} mimeType
+ * @property {String} ctxName
+ * @property {String} cdnUrl
+ * @property {String} cdnUrlModifiers
+ * @property {UploadcareFile} fileInfo
+ * @property {Boolean} isUploading
+ * @property {String} thumbUrl
+ * @property {Boolean} silent
+ * @property {({
+ *   type: import('..').OutputFileErrorType | import('..').OutputCollectionErrorType;
+ *   message: string;
+ * } & Record<string, unknown>)[]} errors
+ * @property {Error | null} uploadError
+ * @property {string | null} fullPath
+ * @property {import('@uploadcare/upload-client').Metadata | null} metadata
+ * @property {boolean} isRemoved
+ */
+
+/**
+ * @template {keyof UploadEntry} K
+ * @type {Record<K, { type: Function; value: any; nullable?: Boolean }>}
+ */
+export const uploadEntrySchema = Object.freeze({
+  file: {
+    type: File,
+    value: null,
+  },
+  externalUrl: {
+    type: String,
+    value: null,
+  },
+  fileName: {
+    type: String,
+    value: null,
+    nullable: true,
+  },
+  fileSize: {
+    type: Number,
+    value: null,
+    nullable: true,
+  },
+  lastModified: {
+    type: Number,
+    value: Date.now(),
+  },
+  uploadProgress: {
+    type: Number,
+    value: 0,
+  },
+  uuid: {
+    type: String,
+    value: null,
+  },
+  isImage: {
+    type: Boolean,
+    value: false,
+  },
+  mimeType: {
+    type: String,
+    value: null,
+    nullable: true,
+  },
+  ctxName: {
+    type: String,
+    value: null,
+  },
+  cdnUrl: {
+    type: String,
+    value: null,
+  },
+  cdnUrlModifiers: {
+    type: String,
+    value: null,
+  },
+  fileInfo: {
+    type: UploadcareFile,
+    value: null,
+  },
+  isUploading: {
+    type: Boolean,
+    value: false,
+  },
+  abortController: {
+    type: AbortController,
+    value: null,
+    nullable: true,
+  },
+  thumbUrl: {
+    type: String,
+    value: null,
+    nullable: true,
+  },
+  silent: {
+    type: Boolean,
+    value: false,
+  },
+  source: {
+    type: String,
+    value: false,
+    nullable: true,
+  },
+  fullPath: {
+    type: String,
+    value: null,
+    nullable: true,
+  },
+  metadata: {
+    type: Object,
+    value: null,
+    nullable: true,
+  },
+  errors: {
+    type: Array,
+    value: [],
+  },
+  uploadError: {
+    type: Error,
+    value: null,
+    nullable: true,
+  },
+  isRemoved: {
+    type: Boolean,
+    value: false,
+  },
+});

package/blocks/ActivityHeader/ActivityHeader.d.ts

@@ -0,0 +1,4 @@
+export class ActivityHeader extends ActivityBlock {
+}
+import { ActivityBlock } from '../../abstract/ActivityBlock.js';
+//# sourceMappingURL=ActivityHeader.d.ts.map

package/blocks/ActivityHeader/ActivityHeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActivityHeader.d.ts","sourceRoot":"","sources":["ActivityHeader.js"],"names":[],"mappings":"AAEA;CAAoD;8BAFtB,iCAAiC"}

package/blocks/ActivityHeader/ActivityHeader.js

@@ -0,0 +1,3 @@
+import { ActivityBlock } from '../../abstract/ActivityBlock.js';
+
+export class ActivityHeader extends ActivityBlock {}

package/blocks/ActivityHeader/activity-header.css

@@ -0,0 +1,14 @@
+uc-activity-header {
+  display: flex;
+  justify-content: space-between;
+  gap: var(--uc-padding);
+  padding: var(--uc-padding);
+  color: var(--uc-foreground);
+  font-weight: 500;
+  font-size: 1em;
+}
+
+uc-activity-header > * {
+  display: flex;
+  align-items: center;
+}

package/blocks/CameraSource/CameraSource.d.ts

@@ -0,0 +1,39 @@
+export class CameraSource extends UploaderBlock {
+    activityType: "camera";
+    /** @private */
+    private _unsubPermissions;
+    init$: any;
+    /** @type {String} */
+    _selectedCameraId: string | undefined;
+    /** @private */
+    private _onActivate;
+    /** @private */
+    private _onDeactivate;
+    /** @private */
+    private _handlePermissionsChange;
+    /**
+     * @private
+     * @param {'granted' | 'denied' | 'prompt'} state
+     */
+    private _setPermissionsState;
+    /** @private */
+    private _subscribePermissions;
+    /** @private */
+    private _capture;
+    /** @private */
+    private _canvas;
+    /** @private */
+    private _ctx;
+    /** @private */
+    private _capturing;
+    /** @private */
+    private _stopCapture;
+    /** @private */
+    private _shot;
+    initCallback(): Promise<void>;
+}
+export namespace CameraSource {
+    let template: string;
+}
+import { UploaderBlock } from '../../abstract/UploaderBlock.js';
+//# sourceMappingURL=CameraSource.d.ts.map