@loaders.gl/video 4.0.0-alpha.1 → 4.0.0-alpha.11

package/dist/gif-builder.js

@@ -1,120 +1,142 @@
-import { assert } from './lib/utils/assert';
-import gifshot from './libs/gifshot';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// A GIFBuilder based on the gifshot module
+// @ts-nocheck
+const assert_1 = require("./lib/utils/assert");
+const gifshot_1 = __importDefault(require("./lib/gifshot/gifshot")); // TODO - load dynamically to avoid bloating
+// These are gifshot module options
 const GIF_BUILDER_OPTIONS = {
-  source: 'images',
-  width: 200,
-  height: 200,
-  crossOrigin: 'Anonymous',
-  progressCallback: captureProgress => {},
-  completeCallback: () => {},
-  numWorkers: 2,
-  sampleInterval: 10,
-  interval: 0.1,
-  offset: null,
-  numFrames: 10,
-  frameDuration: 1,
-  filter: '',
-  waterMark: null,
-  waterMarkHeight: null,
-  waterMarkWidth: null,
-  waterMarkXCoordinate: 1,
-  waterMarkYCoordinate: 1,
-  text: '',
-  showFrameText: true,
-  fontWeight: 'normal',
-  fontSize: '16px',
-  minFontSize: '10px',
-  resizeFont: false,
-  fontFamily: 'sans-serif',
-  fontColor: '#ffffff',
-  textAlign: 'center',
-  textBaseline: 'bottom',
-  textXCoordinate: null,
-  textYCoordinate: null,
-  webcamVideoElement: null,
-  keepCameraOn: false,
-  cameraStream: null,
-  saveRenderingContexts: false,
-  savedRenderingContexts: []
+    source: 'images',
+    width: 200,
+    height: 200,
+    crossOrigin: 'Anonymous',
+    // CALLBACKS
+    progressCallback: (captureProgress) => { },
+    completeCallback: () => { },
+    // QUALITY SETTINGS
+    numWorkers: 2,
+    sampleInterval: 10,
+    interval: 0.1,
+    offset: null,
+    numFrames: 10,
+    frameDuration: 1,
+    // CSS FILTER OPTIONS
+    filter: '',
+    // WATERMARK OPTIONS
+    waterMark: null,
+    waterMarkHeight: null,
+    waterMarkWidth: null,
+    waterMarkXCoordinate: 1,
+    waterMarkYCoordinate: 1,
+    // TEXT OPTIONS
+    text: '',
+    showFrameText: true,
+    fontWeight: 'normal',
+    fontSize: '16px',
+    minFontSize: '10px',
+    resizeFont: false,
+    fontFamily: 'sans-serif',
+    fontColor: '#ffffff',
+    textAlign: 'center',
+    textBaseline: 'bottom',
+    textXCoordinate: null,
+    textYCoordinate: null,
+    // ADVANCED OPTIONS
+    // WEBCAM CAPTURE OPTIONS
+    webcamVideoElement: null,
+    keepCameraOn: false,
+    cameraStream: null,
+    // CANVAS OPTIMIZATION OPTIONS
+    saveRenderingContexts: false,
+    savedRenderingContexts: [] // Array of canvas image data
 };
-export default class GIFBuilder {
-  static get properties() {
-    return {
-      id: 'gif',
-      name: 'GIF',
-      extensions: ['gif'],
-      mimeTypes: ['image/gif'],
-      builder: GIFBuilder,
-      options: GIF_BUILDER_OPTIONS
-    };
-  }
-
-  constructor(options) {
-    this.options = { ...options
-    };
-    this.source = options.source;
-    delete options.source;
-    this.files = [];
-    this.gifshot = gifshot;
-  }
-
-  async initialize(options) {}
-
-  async add(file) {
-    await this.initialize();
-    this.files.push(file);
-  }
-
-  async build() {
-    await this.initialize();
-
-    this._cleanOptions(this.options);
-
-    switch (this.source) {
-      case 'images':
-        this.options.images = this.files;
-        break;
-
-      case 'video':
-        this.options.video = this.files;
-        break;
-
-      case 'webcam':
-        assert(this.files.length === 0);
-        break;
-
-      default:
-        throw new Error('GIFBuilder: invalid source');
+class GIFBuilder {
+    static get properties() {
+        return {
+            id: 'gif',
+            name: 'GIF',
+            extensions: ['gif'],
+            mimeTypes: ['image/gif'],
+            builder: GIFBuilder,
+            options: GIF_BUILDER_OPTIONS
+        };
+    }
+    constructor(options) {
+        this.options = { ...options };
+        this.source = options.source;
+        delete options.source;
+        // Allow files to be added
+        this.files = [];
+        // Expose the gifshot module so that the full gifshot API is available to apps (Experimental)
+        this.gifshot = gifshot_1.default;
+    }
+    async initialize(options) {
+        // Expose the gifshot module so that the full gifshot API is available to apps (Experimental)
+        // this.gifshot = await loadGifshotModule(options);
+    }
+    async add(file) {
+        await this.initialize();
+        this.files.push(file);
+    }
+    async build() {
+        await this.initialize();
+        this._cleanOptions(this.options);
+        switch (this.source) {
+            case 'images':
+                this.options.images = this.files;
+                break;
+            case 'video':
+                this.options.video = this.files;
+                break;
+            case 'webcam':
+                (0, assert_1.assert)(this.files.length === 0);
+                break;
+            default:
+                throw new Error('GIFBuilder: invalid source');
+        }
+        return await this._createGIF();
+    }
+    // PRIVATE
+    async _createGIF() {
+        return new Promise((resolve, reject) => {
+            this.gifshot.createGIF(this.options, (result) => {
+                // callback object properties
+                // --------------------------
+                // image - Base 64 image
+                // cameraStream - The webRTC MediaStream object
+                // error - Boolean that determines if an error occurred
+                // errorCode - Helpful error label
+                // errorMsg - Helpful error message
+                // savedRenderingContexts - An array of canvas image data (will only be set if the saveRenderingContexts option was used)
+                if (result.error) {
+                    reject(result.errorMsg);
+                    return;
+                }
+                // image - Base 64 image
+                resolve(result.image);
+                // var image = obj.image,
+                // animatedImage = document.createElement('img');
+                // animatedImage.src = image;
+                // document.body.appendChild(animatedImage);
+            });
+        });
     }
-
-    return await this._createGIF();
-  }
-
-  async _createGIF() {
-    return new Promise((resolve, reject) => {
-      this.gifshot.createGIF(this.options, result => {
-        if (result.error) {
-          reject(result.errorMsg);
-          return;
+    // Remove some gifshot options
+    _cleanOptions(options) {
+        if (options.video || options.images || options.gifWidth || options.gifHeight) {
+            console.warn('GIFBuilder: ignoring options'); // eslint-disable-line
         }
-
-        resolve(result.image);
-      });
-    });
-  }
-
-  _cleanOptions(options) {
-    if (options.video || options.images || options.gifWidth || options.gifHeight) {
-      console.warn('GIFBuilder: ignoring options');
+        // We control these through options.source instead
+        delete options.video;
+        delete options.images;
+        // Use width/height props (to standardize across builders)
+        options.gifWidth = options.width;
+        options.gifHeight = options.height;
+        delete options.width;
+        delete options.height;
     }
-
-    delete options.video;
-    delete options.images;
-    options.gifWidth = options.width;
-    options.gifHeight = options.height;
-    delete options.width;
-    delete options.height;
-  }
-
 }
-//# sourceMappingURL=gif-builder.js.map
+exports.default = GIFBuilder;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { VideoLoader } from './video-loader';
+export { default as GIFBuilder } from './gif-builder';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAE3C,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -1,3 +1,10 @@
-export { VideoLoader } from './video-loader';
-export { default as GIFBuilder } from './gif-builder';
-//# sourceMappingURL=index.js.map
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GIFBuilder = exports.VideoLoader = void 0;
+var video_loader_1 = require("./video-loader");
+Object.defineProperty(exports, "VideoLoader", { enumerable: true, get: function () { return video_loader_1.VideoLoader; } });
+var gif_builder_1 = require("./gif-builder");
+Object.defineProperty(exports, "GIFBuilder", { enumerable: true, get: function () { return __importDefault(gif_builder_1).default; } });

package/dist/lib/gifshot/gifshot-loader.d.ts

@@ -0,0 +1,2 @@
+export declare function loadGifshotModule(options?: {}): Promise<any>;
+//# sourceMappingURL=gifshot-loader.d.ts.map

package/dist/lib/gifshot/gifshot-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gifshot-loader.d.ts","sourceRoot":"","sources":["../../../src/lib/gifshot/gifshot-loader.ts"],"names":[],"mappings":"AAKA,wBAAsB,iBAAiB,CAAC,OAAO,KAAK,gBAOnD"}

package/dist/lib/gifshot/gifshot-loader.js

@@ -1,19 +1,22 @@
-import { loadLibrary } from '@loaders.gl/worker-utils';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadGifshotModule = void 0;
+// @ts-nocheck
+const worker_utils_1 = require("@loaders.gl/worker-utils");
 let loadGifshotPromise;
-export async function loadGifshotModule(options = {}) {
-  const modules = options.modules || {};
-
-  if (modules.gifshot) {
-    return modules.gifshot;
-  }
-
-  loadGifshotPromise = loadGifshotPromise || loadGifshot(options);
-  return await loadGifshotPromise;
+async function loadGifshotModule(options = {}) {
+    const modules = options.modules || {};
+    if (modules.gifshot) {
+        return modules.gifshot;
+    }
+    loadGifshotPromise = loadGifshotPromise || loadGifshot(options);
+    return await loadGifshotPromise;
 }
-
+exports.loadGifshotModule = loadGifshotModule;
 async function loadGifshot(options) {
-  options.libraryPath = options.libraryPath || 'libs/';
-  const gifshot = await loadLibrary('gifshot.js', 'gifshot', options);
-  return gifshot || globalThis.gifshot;
+    options.libraryPath = options.libraryPath || 'libs/';
+    const gifshot = await (0, worker_utils_1.loadLibrary)('gifshot.js', 'gifshot', options);
+    // Depends on how import happened...
+    // @ts-ignore TS2339: Property does not exist on type
+    return gifshot || globalThis.gifshot;
 }
-//# sourceMappingURL=gifshot-loader.js.map

package/dist/lib/gifshot/gifshot.d.ts

@@ -0,0 +1,72 @@
+declare function isSupported(): boolean;
+declare function isWebCamGIFSupported(): boolean;
+declare function isSupported$1(): boolean;
+declare function isExistingVideoGIFSupported(codecs: any): boolean;
+declare function stopVideoStreaming(options: any): void;
+declare function createGIF(userOptions: any, callback: any): void;
+declare function takeSnapShot(userOptions: any, callback: any): void;
+declare const API: {
+    utils: Readonly<{
+        default: any;
+    }>;
+    error: Readonly<{
+        default: {
+            validate: (skipObj: any) => {};
+            isValid: (skipObj: any) => boolean;
+            validators: {
+                condition: any;
+                errorCode: string;
+                errorMsg: string;
+            }[];
+            messages: {
+                videoCodecs: {
+                    errorCode: string;
+                    errorMsg: string;
+                };
+            };
+        };
+    }>;
+    defaultOptions: Readonly<{
+        default: {
+            sampleInterval: number;
+            numWorkers: number;
+            filter: string;
+            gifWidth: number;
+            gifHeight: number;
+            interval: number;
+            numFrames: number;
+            frameDuration: number;
+            keepCameraOn: boolean;
+            images: never[];
+            video: null;
+            webcamVideoElement: null;
+            cameraStream: null;
+            text: string;
+            fontWeight: string;
+            fontSize: string;
+            minFontSize: string;
+            resizeFont: boolean;
+            fontFamily: string;
+            fontColor: string;
+            textAlign: string;
+            textBaseline: string;
+            textXCoordinate: null;
+            textYCoordinate: null;
+            progressCallback: () => void;
+            completeCallback: () => void;
+            saveRenderingContexts: boolean;
+            savedRenderingContexts: never[];
+            crossOrigin: string;
+        };
+    }>;
+    createGIF: typeof createGIF;
+    takeSnapShot: typeof takeSnapShot;
+    stopVideoStreaming: typeof stopVideoStreaming;
+    isSupported: typeof isSupported;
+    isWebCamGIFSupported: typeof isWebCamGIFSupported;
+    isExistingVideoGIFSupported: typeof isExistingVideoGIFSupported;
+    isExistingImagesGIFSupported: typeof isSupported$1;
+    VERSION: string;
+};
+export default API;
+//# sourceMappingURL=gifshot.d.ts.map

package/dist/lib/gifshot/gifshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gifshot.d.ts","sourceRoot":"","sources":["../../../src/lib/gifshot/gifshot.ts"],"names":[],"mappings":"AAqYA,iBAAS,WAAW,YAEnB;AAOD,iBAAS,oBAAoB,YAE5B;AAQD,iBAAS,aAAa,YAKrB;AAQD,iBAAS,2BAA2B,CAAC,MAAM,KAAA,WAmB1C;AAqrDD,iBAAS,kBAAkB,CAAC,OAAO,KAAA,QAGlC;AAsJD,iBAAS,SAAS,CAAC,WAAW,KAAA,EAAE,QAAQ,KAAA,QAwCvC;AAOD,iBAAS,YAAY,CAAC,WAAW,KAAA,EAAE,QAAQ,KAAA,QAc1C;AAQD,QAAA,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYR,CAAC;AAEF,eAAe,GAAG,CAAC"}