@octane-xplat/lottie 0.0.1 → 0.10.0

package/src/props.ts

@@ -0,0 +1,133 @@
+import type { Octane } from 'octane/jsx-runtime'
+
+export interface LayoutChildProps {
+	row?: number
+	col?: number
+	rowSpan?: number
+	colSpan?: number
+	dock?: 'left' | 'top' | 'right' | 'bottom'
+	left?: number
+	top?: number
+	flexGrow?: number
+	flexShrink?: number
+	alignSelf?: string
+	order?: number
+}
+
+/** Flex-container props shared by View/Row/Pressable — RN vocabulary, applied
+ *  to the host flexboxlayout natively and the element's style on web.
+ *  `gap` is a dip number (px on web); NS supports it on FlexboxLayout only. */
+export interface FlexContainerProps {
+	justifyContent?: 'start' | 'center' | 'end' | 'space-between' | 'space-around' | 'space-evenly'
+	alignItems?: 'start' | 'center' | 'end' | 'stretch' | 'baseline'
+	flexWrap?: boolean | 'wrap' | 'nowrap' | 'wrap-reverse'
+	gap?: number | string
+	rowGap?: number | string
+	columnGap?: number | string
+}
+
+export type Role =
+	| 'button'
+	| 'link'
+	| 'search'
+	| 'image'
+	| 'heading'
+	| 'adjustable'
+	| 'summary'
+	| 'text'
+	| 'none'
+	| 'progressbar'
+	| 'checkbox'
+	| 'switch'
+	| 'radio'
+	| 'spinbutton'
+	| 'tab'
+
+export interface AccessibilityProps {
+	accessible?: boolean
+	accessibilityLabel?: string
+	accessibilityRole?: Role
+	accessibilityHint?: string
+	accessibilityValue?: string
+	accessibilityState?: {
+		disabled?: boolean
+		selected?: boolean
+		checked?: boolean
+	}
+	accessibilityLiveRegion?: 'none' | 'polite' | 'assertive'
+}
+
+export type LottieFit = 'contain' | 'cover' | 'fill'
+
+export interface LottieEvent {
+	/** Animation duration in milliseconds once loaded (0 before then). */
+	duration?: number
+	/** Failure description. */
+	message?: string
+}
+
+export interface LottieHandle {
+	play(): void
+	pause(): void
+	/** Stop and reset the playhead to the start. */
+	stop(): void
+	/** Seek to a normalized position, 0..1. */
+	seekTo(progress: number): void
+	/** Playback speed multiplier (1 = normal). */
+	setSpeed(n: number): void
+	/** Current playhead position, 0..1. */
+	progress(): number
+	/** Animation duration in milliseconds (0 before load). */
+	duration(): number
+	isPlaying(): boolean
+	/** The platform surface (lottie-web AnimationItem / plugin LottieView). */
+	native: any
+}
+
+/** Lottie animation — lottie-web (svg renderer) on web, vendored
+ *  ui-lottie (`src/vendor/ui-lottie` submodule, `octane-xplat/ui-lottie`
+ *  @ `xplat-vendored`) on native.
+ *  On web, lottie-web evaluates expressions embedded in animation data as
+ *  JavaScript. Load only trusted animation data; expression-bearing files
+ *  require a CSP that allows `unsafe-eval`.
+ *  Progress is always normalized 0..1 and durations are milliseconds on
+ *  every platform (the native plugin reports seconds on iOS). */
+export interface LottieProps extends LayoutChildProps, AccessibilityProps {
+	className?: any
+	style?: any
+	id?: string
+	/** Remote URL; native also accepts `~/` bundle paths, absolute file
+	 *  paths, `res://` names, `.lottie`/`.zip` containers, and raw JSON
+	 *  strings starting with `{`. */
+	src?: string
+	/** Inline animation object — wins over `src` when both are given. */
+	data?: object
+	/** Start playing as soon as the composition loads. Default true —
+	 *  matches lottie-web; the native plugin's own default is false. */
+	autoPlay?: boolean
+	/** Repeat forever. Default false — a finite play is the least
+	 *  surprising shared contract (lottie-web's own default is true). */
+	loop?: boolean
+	/** Controlled playback — leave unset for uncontrolled play. */
+	playing?: boolean
+	/** Controlled playhead position, 0..1. */
+	progress?: number
+	/** Playback speed multiplier (1 = normal). */
+	speed?: number
+	/** Content fitting inside the frame: `contain` (letterbox, default),
+	 *  `cover` (crop to fill), `fill` (stretch). */
+	fit?: LottieFit
+	/** Composition parsed and ready — `e.duration` is the length in ms. */
+	onLoaded?: (e: LottieEvent) => void
+	/** Reached the end; does not fire per loop iteration. */
+	onEnded?: () => void
+	/** Load or parse failure. */
+	onError?: (e: LottieEvent) => void
+	/** Imperative handle — play/pause/seek plus `native` for anything the
+	 *  shared props don't cover. */
+	ref?: Octane.Ref<LottieHandle>
+	/** Platform escape hatches, applied after the shared props. */
+	ios?: Record<string, any>
+	android?: Record<string, any>
+	web?: Record<string, any>
+}

package/src/references.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="@nativescript/types" />
+/// <reference types="vite/client" />
+/// <reference path="../node_modules/@nativescript/core/global-types.d.ts" />

package/src/vendor/ui-lottie/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+	nativescript-lottie
+	Copyright (c) 2017, Brad Martin
+
+	Permission is hereby granted, free of charge, to any person obtaining a copy of
+	this software and associated documentation files (the "Software"), to deal in
+	the Software without restriction, including without limitation the rights to
+	use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+	the Software, and to permit persons to whom the Software is furnished to do so,
+	subject to the following conditions:
+
+	The above copyright notice and this permission notice shall be included in all
+	copies or substantial portions of the Software.
+
+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+	FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+	COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+	IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+	CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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);