@octane-xplat/lottie 0.0.1 → 0.10.0

package/src/vendor/ui-lottie/src/lottie/index.d.ts

@@ -0,0 +1,133 @@
+import { Color, View } from '@nativescript/core';
+
+export enum RenderMode {
+    AUTOMATIC,
+    HARDWARE,
+    SOFTWARE
+}
+
+export interface KeyPathColors {
+    [k: string]: Color | string;
+}
+
+export class LottieView extends View {
+    /**
+     * The composition finished loading. `event.composition` is the native
+     * composition object.
+     */
+    static compositionLoadedEvent: string;
+
+    /**
+     * The src failed to load or parse. `event.error` carries the failure.
+     */
+    static loadFailedEvent: string;
+
+    /**
+     * LottieAnimationView
+     */
+    readonly android: any;
+
+    /**
+     * AnimationView
+     */
+    readonly ios: any;
+
+    constructor();
+
+    /**
+     * Flag determining whether the animation should start playing as soon as the view is ready.
+     */
+    autoPlay: boolean;
+
+    /**
+     * Block to be executed upon completion of the animation.
+     * The animation is considered complete when it finishes playing and is no longer looping.
+     */
+    completionBlock: (animationFinished: boolean) => void;
+
+    /**
+     * (iOS only) The current UIViewContentMode.
+     */
+    contentMode: any;
+
+    /**
+     * The duration of the animation.
+     */
+    readonly duration: number | undefined;
+
+    /**
+     * Flag determining whether the animation should loop or not.
+     */
+    loop: boolean;
+
+    /**
+     * Load the source asynchronously instead of blocking the main thread
+     * (Android only — iOS always resolves synchronously).
+     */
+    async: boolean;
+
+    /**
+     * How the animation scales inside the view's bounds — NativeScript's
+     * ImageStretchType ('none' | 'fill' | 'aspectFit' | 'aspectFill').
+     */
+    stretch: string;
+
+    /**
+     * The current progress of the animation.
+     */
+    progress: number | undefined;
+
+    /**
+     * The current speed of the animation.
+     */
+    speed: number | undefined;
+
+    /**
+     * The current source of the animation. Accepts inline JSON (string
+     * starting with '{'), res:// resource names, ~/ app paths, absolute
+     * file paths, and http(s) URLs (downloaded to a temp file).
+     */
+    src: string | undefined;
+
+    /**
+     * (Android) Cancels the animation.
+     *
+     * (iOS) Pauses the animation.
+     */
+    cancelAnimation(): void;
+
+    /**
+     * Pauses the animation, keeping the current progress.
+     */
+    pauseAnimation(): void;
+
+    /**
+     * Resumes the animation from where it was paused.
+     */
+    resumeAnimation(): void;
+
+    /**
+     * Returns true if the view is currently animating.
+     */
+    isAnimating(): boolean;
+
+    /**
+     * Sets the provided color value on each property that matches the specified keyPath.
+     */
+    setColor(value: Color, keyPath: string[]): void;
+
+    /**
+     * Sets the provided opacity value on each property that matches the specified keyPath.
+     */
+    setOpacity(value: number, keyPath: string[]): void;
+
+    /**
+     * Plays the animation from the beginning.
+     */
+    playAnimation(): void;
+
+    /**
+     * Plays the animation from the specified start and end progress values (between 0 and 1).
+     */
+    playAnimationFromProgressToProgress(startProgress: number, endProgress: number): void;
+}

package/src/vendor/ui-lottie/src/lottie/index.ios.ts

@@ -0,0 +1,345 @@
+/**********************************************************************************
+ * (c) 2017, Nathan Walker.
+ * Licensed under the MIT license.
+ *
+ * Version 1.0.0                                           walkerrunpdx@gmail.com
+ **********************************************************************************/
+
+// Vendored from @nativescript-community/ui-lottie (MIT), fork branch
+// xplat-fixes on octane-xplat/ui-lottie — device-probed fixes for dead
+// sync-src, missing events/pause-resume, URL/.lottie sources, async
+// autoPlay, completion dedupe, opacity scale, Podfile pin.
+// @ts-nocheck — vendored upstream code, not strict-clean; kept
+// diff-identical to the fork so fix branches stay PR-able.
+/// <reference path="./typings/ios.d.ts" />
+import { Color, Http, Utils, View, knownFolders, path } from '@nativescript/core';
+import { LottieViewBase, autoPlayProperty, keyPathColorsProperty, loopProperty, progressProperty, srcProperty, stretchProperty } from './index.common';
+import { clamp } from './utils';
+
+const appPath = knownFolders.currentApp().path;
+
+// this remove assert for lottie allowing sync .lottie files loading on main thread
+CompatibleLottieLogger.overrideLottieLogger();
+
+export class LottieView extends LottieViewBase {
+    nativeViewProtected: CompatibleAnimationView;
+    private _imageSourceAffectsLayout = true;
+
+    public createNativeView() {
+        return CompatibleAnimationView.new();
+    }
+
+    public initNativeView(): void {
+        super.initNativeView();
+        this.nativeViewProtected.translatesAutoresizingMaskIntoConstraints = true;
+    }
+
+    public onLoaded() {
+        super.onLoaded();
+        if (this.autoPlay && !this.isAnimating()) {
+            this.playAnimation();
+        }
+    }
+
+    [keyPathColorsProperty.setNative](value) {
+        Object.keys(value).forEach((k) => this.setColor(value[k], k.split('|')));
+    }
+
+    [srcProperty.setNative](src: string) {
+        try {
+            if (!src) {
+                this.nativeViewProtected.compatibleAnimation = null;
+            } else if (src[0] === '{') {
+                this.nativeViewProtected.compatibleAnimation = CompatibleAnimation.alloc().initWithJson(src);
+            } else if (src.startsWith(Utils.RESOURCE_PREFIX)) {
+                const resName = src.replace(Utils.RESOURCE_PREFIX, '');
+
+                this.nativeViewProtected.compatibleAnimation = CompatibleAnimation.alloc().initWithNameBundle(resName.replace('.json', '').replace('.lottie', ''), NSBundle.mainBundle);
+            } else if (/^https?:/i.test(src)) {
+                // Remote URL — download to a temp file and re-enter as a local
+                // path (initWithUrl exists only as a view initializer, so it
+                // can't be applied to an already-created view).
+                const match = /\.(zip|lottie|json)(?=[?#]|$)/i.exec(src);
+                const dest = path.join(knownFolders.temp().path, `lottie-${Date.now()}${match ? match[0].toLowerCase() : '.json'}`);
+                Http.getFile(src, dest)
+                    .then(() => {
+                        this.src = dest;
+                    })
+                    .catch((error) => {
+                        console.error(error);
+                        this.notify({ eventName: 'loadFailed', error });
+                    });
+            } else {
+                if (src[0] === '~') {
+                    src = `${path.join(appPath, src.substring(2))}`;
+                }
+                if (!/.(json|zip|lottie)$/.test(src)) {
+                    src += '.json';
+                }
+                if (!src.startsWith('file:/') && src[0] !== '/') {
+                    // seen as res
+                    this.nativeViewProtected.compatibleAnimation = CompatibleAnimation.alloc().initWithNameSubdirectoryBundle(src.replace('.json', '').replace('.lottie', ''), null, NSBundle.mainBundle);
+                } else {
+                    this.nativeViewProtected.compatibleAnimation = CompatibleAnimation.alloc().initWithFilepath(src);
+                }
+            }
+            if (this.keyPathColors) {
+                this[keyPathColorsProperty.setNative](this.keyPathColors);
+            }
+            if (this._imageSourceAffectsLayout) {
+                this.requestLayout();
+            }
+
+            if (this.autoPlay && !this.isAnimating()) {
+                this.playAnimation();
+            }
+
+            if (src && !/^https?:/i.test(src)) {
+                // CompatibleAnimation decodes synchronously when assigned (the
+                // bundled lottie-ios fork overrides the main-thread logger
+                // assert so .lottie decodes inline too). Notify deferred,
+                // matching the Android event shape and letting listeners
+                // attached around the src assignment still fire. Success is
+                // animationDuration >= 0 — `compatibleAnimation`'s didSet
+                // writes `animationView.animation` without touching the view's
+                // own `animation` property, so `view.animation` stays nil and
+                // can't be used as the signal. `animationDuration` is -1 only
+                // when nothing decoded.
+                const view = this.nativeViewProtected;
+                setTimeout(() => {
+                    if (view && view.compatibleAnimation && view.animationDuration >= 0) {
+                        this.notify({ eventName: LottieViewBase.compositionLoadedEvent, composition: view.compatibleAnimation });
+                    } else {
+                        this.notify({ eventName: LottieViewBase.loadFailedEvent, error: src });
+                    }
+                }, 0);
+            }
+        } catch (error) {
+            console.error(error);
+            this.notify({ eventName: LottieViewBase.loadFailedEvent, error });
+        }
+    }
+
+    [loopProperty.setNative](loop: boolean) {
+        this.nativeViewProtected.loopAnimationCount = loop ? -1 : 0;
+    }
+
+    [autoPlayProperty.setNative](autoPlay: boolean) {
+        if (autoPlay) {
+            if (!this.isAnimating()) {
+                this.playAnimation();
+            }
+        } else {
+            if (this.isAnimating()) {
+                this.cancelAnimation();
+            }
+        }
+    }
+
+    public setColor(value: Color, keyPath: string[]): void {
+        if (this.nativeView && value && keyPath && keyPath.length) {
+            if (keyPath[keyPath.length - 1].toLowerCase() !== 'color') {
+                keyPath = [...keyPath];
+                keyPath.push('Color'); // ios expects the property as the last item in the keyPath
+            }
+
+            const color = value instanceof Color ? value : new Color(value);
+            this.nativeViewProtected.setColorValueForKeypath(color.ios, CompatibleAnimationKeypath.alloc().initWithKeypath(keyPath.join('.')));
+        }
+    }
+
+    public setOpacity(value: number, keyPath: string[]): void {
+        if (this.nativeView && value != null && keyPath && keyPath.length) {
+            keyPath = [...keyPath];
+            if (keyPath[keyPath.length - 1].toLowerCase() !== 'opacity') {
+                keyPath.push('Opacity'); // ios expects the property as the last item in the keyPath
+            }
+
+            // Opacity float values are on a 0–100 scale in lottie-ios
+            // (After Effects percent), matching the Android setter's input
+            // contract of a 0–1 fraction.
+            this.nativeViewProtected.setFloatValueForKeypath(clamp(value) * 100, CompatibleAnimationKeypath.alloc().initWithKeypath(keyPath.join('.')));
+        }
+        // TODO: not working
+        // if (this.nativeView && value && keyPath && keyPath.length) {
+        //   if (keyPath[keyPath.length - 1].toLowerCase() !== 'opacity') {
+        //     keyPath.push('Opacity'); // ios expects the property as the last item in the keyPath
+        //   }
+        //   value = clamp(value);
+        //   this.nativeViewProtected.getValue(
+        //     LOTNumberValueCallback.withFloatValue(value),
+        //     AnimationKeypath.keypathWithString(keyPath.join('.'))
+        //   );
+        // }
+    }
+
+    public playAnimation(): void {
+        setTimeout(() => {
+            if (this.nativeViewProtected) {
+                if (this.completionBlock) {
+                    this.nativeViewProtected.playWithCompletion((animationFinished: boolean) => {
+                        if (this.completionBlock) {
+                            this.completionBlock(animationFinished);
+                        }
+                    });
+                } else {
+                    this.nativeViewProtected.play();
+                }
+            }
+        }, 0);
+    }
+
+    public playAnimationFromProgressToProgress(startProgress: number, endProgress: number): void {
+        if (this.nativeViewProtected) {
+            startProgress = startProgress ? clamp(startProgress) : 0;
+            endProgress = endProgress ? clamp(endProgress) : 1;
+            if (this.completionBlock) {
+                this.nativeViewProtected.playFromProgressToProgressCompletion(startProgress, endProgress, this.completionBlock);
+            } else {
+                this.nativeViewProtected.playFromProgressToProgressCompletion(startProgress, endProgress, null);
+            }
+        }
+    }
+
+    public cancelAnimation(): void {
+        if (this.nativeViewProtected) {
+            this.nativeViewProtected.pause();
+        }
+    }
+
+    public pauseAnimation(): void {
+        if (this.nativeViewProtected) {
+            this.nativeViewProtected.pause();
+        }
+    }
+
+    public resumeAnimation(): void {
+        if (this.nativeViewProtected) {
+            // play() with no fromProgress resumes from currentProgress
+            this.nativeViewProtected.play();
+        }
+    }
+
+    public isAnimating(): boolean {
+        return this.nativeView ? this.nativeViewProtected.isAnimationPlaying : false;
+    }
+
+    [progressProperty.setNative](value: number) {
+        this.nativeViewProtected.currentProgress = value;
+    }
+
+    public set speed(value: number) {
+        if (this.nativeView && value) {
+            this.nativeViewProtected.animationSpeed = value;
+        }
+    }
+
+    public get speed(): number | undefined {
+        return this.nativeView ? this.nativeViewProtected.animationSpeed : undefined;
+    }
+
+    public get duration(): number | undefined {
+        return this.nativeView && this.nativeViewProtected.animationDuration;
+    }
+
+    public set contentMode(mode: any) {
+        // this._contentMode = mode;
+        if (this.nativeViewProtected) {
+            this.nativeViewProtected.contentMode = mode;
+        }
+    }
+
+    public onMeasure(widthMeasureSpec: number, heightMeasureSpec: number): void {
+        const intrinsicContentSize = this.nativeViewProtected.intrinsicContentSize;
+        // We don't call super because we measure native view with specific size.
+        const width = Utils.layout.getMeasureSpecSize(widthMeasureSpec);
+        const widthMode = Utils.layout.getMeasureSpecMode(widthMeasureSpec);
+
+        const height = Utils.layout.getMeasureSpecSize(heightMeasureSpec);
+        const heightMode = Utils.layout.getMeasureSpecMode(heightMeasureSpec);
+
+        const nativeWidth = intrinsicContentSize ? Utils.layout.toDevicePixels(intrinsicContentSize.width) : 0;
+        const nativeHeight = intrinsicContentSize ? Utils.layout.toDevicePixels(intrinsicContentSize.height) : 0;
+
+        let measureWidth = Math.max(nativeWidth, this.effectiveMinWidth);
+        let measureHeight = Math.max(nativeHeight, this.effectiveMinHeight);
+
+        const finiteWidth: boolean = widthMode !== Utils.layout.UNSPECIFIED;
+        const finiteHeight: boolean = heightMode !== Utils.layout.UNSPECIFIED;
+
+        this._imageSourceAffectsLayout = widthMode !== Utils.layout.EXACTLY || heightMode !== Utils.layout.EXACTLY;
+
+        if (nativeWidth !== 0 && nativeHeight !== 0 && (finiteWidth || finiteHeight)) {
+            const scale = LottieView.computeScaleFactor(width, height, finiteWidth, finiteHeight, nativeWidth, nativeHeight, this.stretch);
+            const resultW = Math.round(nativeWidth * scale.width);
+            const resultH = Math.round(nativeHeight * scale.height);
+
+            measureWidth = finiteWidth ? Math.min(resultW, width) : resultW;
+            measureHeight = finiteHeight ? Math.min(resultH, height) : resultH;
+        }
+
+        const widthAndState = View.resolveSizeAndState(measureWidth, width, widthMode, 0);
+        const heightAndState = View.resolveSizeAndState(measureHeight, height, heightMode, 0);
+
+        this.setMeasuredDimension(widthAndState, heightAndState);
+    }
+
+    private static computeScaleFactor(
+        measureWidth: number,
+        measureHeight: number,
+        widthIsFinite: boolean,
+        heightIsFinite: boolean,
+        nativeWidth: number,
+        nativeHeight: number,
+        imageStretch: string
+    ): { width: number; height: number } {
+        let scaleW = 1;
+        let scaleH = 1;
+
+        if ((imageStretch === 'aspectFill' || imageStretch === 'aspectFit' || imageStretch === 'fill') && (widthIsFinite || heightIsFinite)) {
+            scaleW = nativeWidth > 0 ? measureWidth / nativeWidth : 0;
+            scaleH = nativeHeight > 0 ? measureHeight / nativeHeight : 0;
+
+            if (!widthIsFinite) {
+                scaleW = scaleH;
+            } else if (!heightIsFinite) {
+                scaleH = scaleW;
+            } else {
+                // No infinite dimensions.
+                switch (imageStretch) {
+                    case 'aspectFit':
+                        scaleH = scaleW < scaleH ? scaleW : scaleH;
+                        scaleW = scaleH;
+                        break;
+                    case 'aspectFill':
+                        scaleH = scaleW > scaleH ? scaleW : scaleH;
+                        scaleW = scaleH;
+                        break;
+                }
+            }
+        }
+
+        return { width: scaleW, height: scaleH };
+    }
+
+    [stretchProperty.setNative](value: 'none' | 'aspectFill' | 'aspectFit' | 'fill') {
+        switch (value) {
+            case 'aspectFit':
+                this.nativeViewProtected.contentMode = UIViewContentMode.ScaleAspectFit;
+                break;
+
+            case 'aspectFill':
+                this.nativeViewProtected.contentMode = UIViewContentMode.ScaleAspectFill;
+                break;
+
+            case 'fill':
+                this.nativeViewProtected.contentMode = UIViewContentMode.ScaleToFill;
+                break;
+
+            case 'none':
+            default:
+                this.nativeViewProtected.contentMode = UIViewContentMode.TopLeft;
+                break;
+        }
+    }
+}