@octane-xplat/lottie 0.0.1 → 0.9.0

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

@@ -0,0 +1,447 @@
+/**********************************************************************************
+ * (c) 2017, Brad Martin.
+ * Licensed under the MIT license.
+ *
+ * Version 1.0.0                                           bradwaynemartin@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/android.d.ts" />
+import { Color, File, Http, Utils, knownFolders, path } from '@nativescript/core';
+import { LottieViewBase, autoPlayProperty, keyPathColorsProperty, loopProperty, progressProperty, renderModeProperty, srcProperty, stretchProperty } from './index.common';
+import { clamp } from './utils';
+
+let LottieProperty: typeof com.airbnb.lottie.LottieProperty;
+let LottieKeyPath: typeof com.airbnb.lottie.model.KeyPath;
+let LottieValueCallback: typeof com.airbnb.lottie.value.LottieValueCallback;
+let LottieCompositionFactory: typeof com.airbnb.lottie.LottieCompositionFactory;
+
+const cache = new Map();
+async function loadLottieJSON(iconSrc) {
+    if (!cache.has(iconSrc)) {
+        const file = File.fromPath(iconSrc);
+        const r = await file.readText();
+        cache.set(iconSrc, r);
+        return r;
+    }
+    return cache.get(iconSrc);
+}
+function loadLottieJSONSync(iconSrc) {
+    if (!cache.has(iconSrc)) {
+        const file = File.fromPath(iconSrc);
+        const r = file.readTextSync();
+        cache.set(iconSrc, r);
+        return r;
+    }
+    return cache.get(iconSrc);
+}
+
+export const RenderMode = {
+    get AUTOMATIC() {
+        return com.airbnb.lottie.RenderMode.AUTOMATIC;
+    },
+    get HARDWARE() {
+        return com.airbnb.lottie.RenderMode.HARDWARE;
+    },
+    get SOFTWARE() {
+        return com.airbnb.lottie.RenderMode.SOFTWARE;
+    }
+};
+
+export class LottieView extends LottieViewBase {
+    nativeViewProtected: com.airbnb.lottie.LottieAnimationView;
+
+    public createNativeView() {
+        return new com.nativescript.lottie.LottieAnimationView(this._context);
+    }
+
+    animatorListener: android.animation.Animator.AnimatorListener;
+    loadedListener: com.airbnb.lottie.LottieOnCompositionLoadedListener;
+    _completionBlock;
+    _cancelled = false;
+    //@ts-ignore
+    get completionBlock() {
+        return this._completionBlock;
+    }
+    set completionBlock(block) {
+        this._completionBlock = block;
+        if (block) {
+            if (!this.animatorListener) {
+                const that = new WeakRef(this);
+                this.animatorListener = new android.animation.Animator.AnimatorListener({
+                    onAnimationCancel: (_animator) => {
+                        // ValueAnimator.cancel() fires onAnimationCancel AND then
+                        // onAnimationEnd — report once, in onAnimationEnd, with the
+                        // correct finished flag (matching iOS, where pause()/stop()
+                        // invoke the completion block a single time with false).
+                        const owner = that?.get();
+                        if (owner) {
+                            owner._cancelled = true;
+                        }
+                    },
+                    onAnimationEnd: (_animator) => {
+                        const owner = that?.get();
+                        if (owner?._completionBlock) {
+                            owner._completionBlock(!owner._cancelled);
+                        }
+                        if (owner) {
+                            owner._cancelled = false;
+                        }
+                    },
+                    onAnimationRepeat: (_animator) => {
+                        // noop
+                    },
+                    onAnimationStart: (_animator) => {
+                        // noop
+                    }
+                });
+                if (this.nativeViewProtected) {
+                    this.nativeViewProtected.addAnimatorListener(this.animatorListener);
+                }
+            }
+        } else if (this.animatorListener) {
+            if (this.nativeViewProtected) {
+                this.nativeViewProtected.removeAnimatorListener(this.animatorListener);
+            }
+            this.animatorListener = null;
+        }
+    }
+    public initNativeView(): void {
+        if (this.animatorListener) {
+            this.nativeViewProtected.addAnimatorListener(this.animatorListener);
+        }
+        if (!this.loadedListener) {
+            const that = new WeakRef(this);
+            this.loadedListener = new com.airbnb.lottie.LottieOnCompositionLoadedListener({
+                onCompositionLoaded: (composition) => {
+                    const owner = that?.get();
+                    if (owner) {
+                        // delay just a bit so that it get received in sync load
+                        setTimeout(() => {
+                            owner.notify({ eventName: LottieViewBase.compositionLoadedEvent, composition });
+                            // async loads arrive after the autoPlay property
+                            // setter ran — playAnimation() there was a no-op on
+                            // an empty view, so re-trigger on composition arrival.
+                            if (owner.autoPlay && !owner.isAnimating()) {
+                                owner.playAnimation();
+                            }
+                        }, 0);
+                    }
+                }
+            });
+        }
+        this.nativeViewProtected.addLottieOnCompositionLoadedListener(this.loadedListener);
+        const that = new WeakRef(this);
+        this.nativeViewProtected.setFailureListener(
+            new com.airbnb.lottie.LottieListener<java.lang.Throwable>({
+                onResult: (result) => {
+                    const owner = that?.get();
+                    if (owner) {
+                        owner.notify({ eventName: LottieViewBase.loadFailedEvent, error: result });
+                    }
+                }
+            })
+        );
+    }
+
+    public disposeNativeView(): void {
+        if (this.animatorListener) {
+            this.nativeViewProtected.removeAnimatorListener(this.animatorListener);
+        }
+        if (this.loadedListener) {
+            this.nativeViewProtected.removeLottieOnCompositionLoadedListener(this.loadedListener);
+        }
+        super.disposeNativeView();
+    }
+
+    public setColor(value: Color | string, keyPath: string[]): void {
+        const nativeView = this.nativeViewProtected;
+        if (nativeView && value && keyPath && keyPath.length) {
+            if (keyPath[keyPath.length - 1].toLowerCase() === 'color') {
+                keyPath = [...keyPath];
+                keyPath.pop(); // android specifies the property as an enum parameter.
+                if (keyPath.length === 0) {
+                    return;
+                }
+            }
+            const nativeKeyPath: any[] = Array.create(java.lang.String, keyPath.length);
+            for (let index = 0; index < keyPath.length; index++) {
+                nativeKeyPath[index] = keyPath[index];
+            }
+            if (!LottieProperty) {
+                LottieProperty = com.airbnb.lottie.LottieProperty;
+            }
+            if (!LottieValueCallback) {
+                LottieValueCallback = com.airbnb.lottie.value.LottieValueCallback;
+            }
+
+            if (!LottieKeyPath) {
+                LottieKeyPath = com.airbnb.lottie.model.KeyPath;
+            }
+            // by using color filter we change all colors (STROKE_COLOR and COLOR)
+            const color = value instanceof Color ? value : new Color(value);
+            // const colorFilter = new android.graphics.PorterDuffColorFilter(value.android, 	android.graphics.PorterDuff.Mode.SRC_ATOP) ;
+            const colorFilter = new com.airbnb.lottie.SimpleColorFilter(color.android);
+            nativeView.addValueCallback(new LottieKeyPath(nativeKeyPath as any), LottieProperty.COLOR_FILTER, new LottieValueCallback(colorFilter));
+            // nativeView.addValueCallback(
+            //     new LottieKeyPath(nativeKeyPath as any),
+            //     LottieProperty.COLOR,
+            //     new LottieValueCallback(java.lang.Integer.valueOf(value.android))
+            // );
+        }
+    }
+
+    public setOpacity(value: number, keyPath: string[]): void {
+        if (this.nativeViewProtected && value != null && keyPath && keyPath.length) {
+            if (keyPath[keyPath.length - 1].toLowerCase() === 'opacity') {
+                keyPath = [...keyPath];
+                keyPath.pop(); // android specifies the property as an enum parameter.
+                if (keyPath.length === 0) {
+                    return;
+                }
+            }
+            const nativeKeyPath: java.lang.String[] = Array.create(java.lang.String, keyPath.length);
+            keyPath.forEach((key, index) => {
+                nativeKeyPath[index] = new java.lang.String(key);
+            });
+            value = clamp(value);
+            if (!LottieProperty) {
+                LottieProperty = com.airbnb.lottie.LottieProperty;
+            }
+            if (!LottieValueCallback) {
+                LottieValueCallback = com.airbnb.lottie.value.LottieValueCallback;
+            }
+
+            if (!LottieKeyPath) {
+                LottieKeyPath = com.airbnb.lottie.model.KeyPath;
+            }
+            // LottieProperty.OPACITY is an Integer on a 0–255 scale (matching
+            // Paint#setAlpha), not a 0–100 percentage.
+            this.nativeViewProtected.addValueCallback(new LottieKeyPath(nativeKeyPath as any), LottieProperty.OPACITY, new LottieValueCallback(new java.lang.Integer(value * 255)));
+        }
+    }
+
+    public playAnimation(): void {
+        if (this.nativeViewProtected) {
+            this.nativeViewProtected.setMinAndMaxProgress(0, 1);
+            this.nativeViewProtected.playAnimation();
+        }
+    }
+
+    public playAnimationFromProgressToProgress(startProgress: number, endProgress: number): void {
+        if (this.nativeViewProtected) {
+            startProgress = startProgress ? clamp(startProgress) : 0;
+            endProgress = endProgress ? clamp(endProgress) : 1;
+            this.nativeViewProtected.setMinAndMaxProgress(startProgress, endProgress);
+            this.nativeViewProtected.playAnimation();
+        }
+    }
+
+    public isAnimating(): boolean {
+        return this.nativeViewProtected ? this.nativeViewProtected.isAnimating() : false;
+    }
+
+    public get speed(): number | undefined {
+        return this.nativeViewProtected ? this.nativeViewProtected.getSpeed() : undefined;
+    }
+
+    public set speed(value: number) {
+        if (this.nativeViewProtected && value) {
+            this.nativeViewProtected.setSpeed(value);
+        }
+    }
+
+    public get duration(): number | undefined {
+        return this.nativeViewProtected ? this.nativeViewProtected.getDuration() : undefined;
+    }
+
+    public cancelAnimation(): void {
+        if (this.nativeViewProtected) {
+            this.nativeViewProtected.cancelAnimation();
+        }
+    }
+
+    public pauseAnimation(): void {
+        if (this.nativeViewProtected) {
+            this.nativeViewProtected.pauseAnimation();
+        }
+    }
+
+    public resumeAnimation(): void {
+        if (this.nativeViewProtected) {
+            this.nativeViewProtected.resumeAnimation();
+        }
+    }
+
+    [srcProperty.setNative](src: string) {
+        try {
+            if (!LottieCompositionFactory) {
+                LottieCompositionFactory = com.airbnb.lottie.LottieCompositionFactory;
+            }
+            const view = this.nativeViewProtected;
+            let result: com.airbnb.lottie.LottieResult<com.airbnb.lottie.LottieComposition>;
+            if (!src) {
+                // lottie does not support "clearing the animation"
+                // view.setAnimation(null);
+            } else if (src[0] === '{') {
+                if (this.async) {
+                    view.setAnimationFromJson(src, null);
+                } else {
+                    result = LottieCompositionFactory.fromJsonStringSync(src, null);
+                }
+            } else if (/^https?:/i.test(src)) {
+                // Remote URL — download to a temp file and re-enter as a
+                // local path. (Android could use LottieCompositionFactory.
+                // fromUrl, but the download path works identically on iOS
+                // and flows failures through loadFailed.)
+                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.startsWith(Utils.RESOURCE_PREFIX)) {
+                const resName = src.replace(Utils.RESOURCE_PREFIX, '');
+                if (this.async) {
+                    view.setAnimation(resName);
+                } else {
+                    result = com.airbnb.lottie.LottieCompositionFactory.fromAssetSync(this._context, resName);
+                }
+            } else {
+                if (!/.(json|zip|lottie)$/.test(src)) {
+                    src += '.json';
+                }
+                if (src[0] === '~') {
+                    if (this.async) {
+                        view.setAnimation('app/' + src.substring(2));
+                    } else {
+                        result = com.airbnb.lottie.LottieCompositionFactory.fromAssetSync(this._context, 'app/' + src.substring(2));
+                    }
+                } else if (!src.startsWith('file:/') && src[0] !== '/') {
+                    if (this.async) {
+                        view.setAnimation('app/' + src);
+                    } else {
+                        result = com.airbnb.lottie.LottieCompositionFactory.fromAssetSync(this._context, src);
+                    }
+                } else {
+                    const filePath = src.startsWith('file:') ? src.substring('file:'.length) : src;
+                    if (/\.(zip|lottie)$/i.test(filePath)) {
+                        // Binary containers can't survive File.readText — hand
+                        // a ZipInputStream to the factory instead.
+                        const stream = new java.util.zip.ZipInputStream(new java.io.FileInputStream(filePath));
+                        if (this.async) {
+                            const owner = new WeakRef(this);
+                            com.airbnb.lottie.LottieCompositionFactory.fromZipStream(stream, null)
+                                .addListener(
+                                    new com.airbnb.lottie.LottieListener<com.airbnb.lottie.LottieComposition>({
+                                        onResult: (composition) => {
+                                            const view = owner.get()?.nativeViewProtected;
+                                            if (view) {
+                                                view.setComposition(composition);
+                                            }
+                                        }
+                                    })
+                                )
+                                .addFailureListener(
+                                    new com.airbnb.lottie.LottieListener<java.lang.Throwable>({
+                                        onResult: (error) => console.error(error)
+                                    })
+                                );
+                        } else {
+                            result = com.airbnb.lottie.LottieCompositionFactory.fromZipStreamSync(stream, null);
+                        }
+                    } else if (this.async) {
+                        loadLottieJSON(src).then((result) => {
+                            if (this.nativeViewProtected) {
+                                this.nativeViewProtected.setAnimationFromJson(result, null);
+                            }
+                        });
+                    } else {
+                        result = LottieCompositionFactory.fromJsonStringSync(loadLottieJSONSync(src), null);
+                    }
+                }
+            }
+            if (result) {
+                if (result.getException()) {
+                    console.error(result.getException());
+                    this.notify({ eventName: LottieViewBase.loadFailedEvent, error: result.getException() });
+                    // view.setComposition(null);
+                } else {
+                    view.setComposition(result.getValue());
+
+                    //in sync loading we need to fire it ourselves
+                    // if we dont differ it from now it wont be received
+                    // setTimeout(() => {
+                    //     this.notify({ eventName: 'compositionLoaded', composition: result.getValue() });
+                    // }, 0);
+                }
+            }
+            if (this.autoPlay) {
+                this.playAnimation();
+            }
+        } catch (error) {
+            console.error(error);
+            this.notify({ eventName: LottieViewBase.loadFailedEvent, error });
+        }
+    }
+
+    [loopProperty.setNative](loop: boolean) {
+        this.nativeViewProtected.setRepeatCount(loop ? -1 /* android.animation.ValueAnimator.INFINITE */ : 0);
+    }
+
+    [progressProperty.setNative](value: number) {
+        this.nativeViewProtected.setProgress(value);
+    }
+    [renderModeProperty.setNative](renderMode) {
+        this.nativeViewProtected.setRenderMode(renderMode);
+    }
+    [keyPathColorsProperty.setNative](value) {
+        Object.keys(value).forEach((k) => this.setColor(value[k], k.split('|')));
+    }
+
+    [autoPlayProperty.setNative](autoPlay: boolean) {
+        if (autoPlay) {
+            if (!this.isAnimating()) {
+                this.playAnimation();
+            }
+        } else {
+            // disable check for now as isAnimating always returns false
+            // if (this.isAnimating()) {
+            this.cancelAnimation();
+            if (this.progress) {
+                this.nativeViewProtected.setProgress(this.progress);
+            }
+            // }
+        }
+    }
+
+    [stretchProperty.getDefault](): 'aspectFit' {
+        return 'aspectFit';
+    }
+    [stretchProperty.setNative](value: 'none' | 'aspectFill' | 'aspectFit' | 'fill') {
+        switch (value) {
+            case 'aspectFit':
+                this.nativeViewProtected.setScaleType(android.widget.ImageView.ScaleType.FIT_CENTER);
+                break;
+            case 'aspectFill':
+                this.nativeViewProtected.setScaleType(android.widget.ImageView.ScaleType.CENTER_CROP);
+                break;
+            case 'fill':
+                this.nativeViewProtected.setScaleType(android.widget.ImageView.ScaleType.FIT_XY);
+                break;
+            case 'none':
+            default:
+                this.nativeViewProtected.setScaleType(android.widget.ImageView.ScaleType.MATRIX);
+                break;
+        }
+    }
+}

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

@@ -0,0 +1,84 @@
+/**********************************************************************************
+ * (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
+// close to the fork so fix branches stay PR-able; divergences are
+// commented inline.
+import { CoreTypes, Property, View, booleanConverter } from '@nativescript/core';
+// KeyPathColors lives here — upstream's `from '.'` self-import
+// doesn't resolve in a vendored layout.
+export interface KeyPathColors {
+    [k: string]: Color | string;
+}
+
+export class LottieViewBase extends View {
+    public static compositionLoadedEvent = 'compositionLoaded';
+    public static loadFailedEvent = 'loadFailed';
+    // `declare`, not plain fields — under useDefineForClassFields (esbuild/
+    // rolldown, es2022+) plain declarations emit instance fields that shadow
+    // the Property accessors register() installs, silently breaking every
+    // property set. Upstream's tsc emit never hit this; vendored fork fix.
+    public declare stretch: CoreTypes.ImageStretchType;
+    public declare async: boolean;
+    public declare src: string;
+    public declare loop: boolean;
+    public declare autoPlay: boolean;
+    public declare progress: number;
+    public declare keyPathColors: KeyPathColors;
+    public declare completionBlock: (animationFinished: boolean) => void;
+}
+
+export const srcProperty = new Property<LottieViewBase, string>({
+    name: 'src'
+});
+srcProperty.register(LottieViewBase);
+
+export const asyncProperty = new Property<LottieViewBase, boolean>({
+    name: 'async',
+    defaultValue: false,
+    valueConverter: booleanConverter
+});
+asyncProperty.register(LottieViewBase);
+export const loopProperty = new Property<LottieViewBase, boolean>({
+    name: 'loop',
+    defaultValue: false,
+    valueConverter: booleanConverter
+});
+loopProperty.register(LottieViewBase);
+
+export const autoPlayProperty = new Property<LottieViewBase, boolean>({
+    name: 'autoPlay',
+    defaultValue: false,
+    valueConverter: booleanConverter
+});
+autoPlayProperty.register(LottieViewBase);
+
+export const renderModeProperty = new Property<LottieViewBase, number>({
+    name: 'renderMode'
+});
+renderModeProperty.register(LottieViewBase);
+
+export const progressProperty = new Property<LottieViewBase, number>({
+    name: 'progress'
+});
+progressProperty.register(LottieViewBase);
+
+export const stretchProperty = new Property<LottieViewBase, CoreTypes.ImageStretchType>({
+    name: 'stretch',
+    defaultValue: 'aspectFit',
+    affectsLayout: global.isIOS
+});
+stretchProperty.register(LottieViewBase);
+
+export const keyPathColorsProperty = new Property<LottieViewBase, KeyPathColors>({
+    name: 'keyPathColors'
+});
+keyPathColorsProperty.register(LottieViewBase);

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;
+}