@symbiote-native/angular 0.1.0

package/build/modules/animated/index.d.ts

@@ -0,0 +1,51 @@
+import { AnimatedValue, AnimatedValueXY, AnimatedColor, timing, spring, decay, parallel, sequence, stagger, loop, delay, add, subtract, multiply, divide, modulo, diffClamp, event, forkEvent, unforkEvent } from '@symbiote-native/engine';
+import { AnimatedImage, AnimatedScrollView, AnimatedText, AnimatedView, createAnimatedComponent } from './create-animated-component';
+export { AnimatedComponentBase, AnimatedFlatList, AnimatedImage, AnimatedScrollView, AnimatedSectionList, AnimatedText, AnimatedView, createAnimatedComponent, } from './create-animated-component';
+export declare const Animated: {
+    Value: typeof AnimatedValue;
+    ValueXY: typeof AnimatedValueXY;
+    Color: typeof AnimatedColor;
+    Easing: {
+        step0(n: number): number;
+        step1(n: number): number;
+        linear(t: number): number;
+        ease(t: number): number;
+        quad(t: number): number;
+        cubic(t: number): number;
+        poly(n: number): import("@symbiote-native/engine").IEasingFunction;
+        sin(t: number): number;
+        circle(t: number): number;
+        exp(t: number): number;
+        elastic(bounciness?: number): import("@symbiote-native/engine").IEasingFunction;
+        back(s?: number): import("@symbiote-native/engine").IEasingFunction;
+        bounce(t: number): number;
+        bezier(x1: number, y1: number, x2: number, y2: number): import("@symbiote-native/engine").IEasingFunction;
+        in(easing: import("@symbiote-native/engine").IEasingFunction): import("@symbiote-native/engine").IEasingFunction;
+        out(easing: import("@symbiote-native/engine").IEasingFunction): import("@symbiote-native/engine").IEasingFunction;
+        inOut(easing: import("@symbiote-native/engine").IEasingFunction): import("@symbiote-native/engine").IEasingFunction;
+    };
+    timing: typeof timing;
+    spring: typeof spring;
+    decay: typeof decay;
+    parallel: typeof parallel;
+    sequence: typeof sequence;
+    stagger: typeof stagger;
+    loop: typeof loop;
+    delay: typeof delay;
+    add: typeof add;
+    subtract: typeof subtract;
+    multiply: typeof multiply;
+    divide: typeof divide;
+    modulo: typeof modulo;
+    diffClamp: typeof diffClamp;
+    event: typeof event;
+    forkEvent: typeof forkEvent;
+    unforkEvent: typeof unforkEvent;
+    View: typeof AnimatedView;
+    Text: typeof AnimatedText;
+    Image: typeof AnimatedImage;
+    ScrollView: typeof AnimatedScrollView;
+    FlatList: typeof import("../..").FlatList;
+    SectionList: typeof import("../..").SectionList;
+    createAnimatedComponent: typeof createAnimatedComponent;
+};

package/build/modules/animated/index.js

@@ -0,0 +1,58 @@
+// The Animated namespace for @symbiote-native/angular: the Angular twin of adapters/vue/src/modules/
+// animated/index.ts. The animated COMPONENTS (View / Text / Image / ScrollView) are explicit
+// standalone components (Angular has no runtime HOC — see create-animated-component.ts); the
+// value graph, easing and imperative drivers come from @symbiote-native/engine (framework-agnostic,
+// JS-driven, ADR 0016), spread in verbatim. Both halves meet here so the familiar surface,
+// `Animated.timing(new Animated.Value(0), …).start()`, works against the Angular-driven engine.
+import { AnimatedValue, AnimatedValueXY, AnimatedColor, AnimatedMock, Easing, Platform, timing, spring, decay, parallel, sequence, stagger, loop, delay, add, subtract, multiply, divide, modulo, diffClamp, event, forkEvent, unforkEvent, } from '@symbiote-native/engine';
+import { AnimatedFlatList, AnimatedImage, AnimatedScrollView, AnimatedSectionList, AnimatedText, AnimatedView, createAnimatedComponent, } from './create-animated-component';
+export { AnimatedComponentBase, AnimatedFlatList, AnimatedImage, AnimatedScrollView, AnimatedSectionList, AnimatedText, AnimatedView, createAnimatedComponent, } from './create-animated-component';
+// ScrollView is exposed DIRECTLY, not behind the lazy getter the React/Vue modules use: that
+// getter only exists to defer a RUNTIME createAnimatedComponent(ScrollView) past module init so
+// it cannot read ScrollView inside its own TDZ during an import cycle. AnimatedScrollView here is
+// a statically-declared component that never reads the ScrollView class at init (it targets the
+// `symbiote-scroll-view` host by string), so there is no cycle to defer.
+//
+// FlatList / SectionList are exposed as explicit AOT-safe list entries now that the Angular list
+// components exist. Angular still cannot synthesize arbitrary animated wrappers at runtime; custom
+// animated components remain explicit standalone components over AnimatedComponentBase.
+// The live, JS-driven driver namespace (real frames). RN's AnimatedImplementation.
+const liveDrivers = {
+    Value: AnimatedValue,
+    ValueXY: AnimatedValueXY,
+    Color: AnimatedColor,
+    Easing,
+    timing,
+    spring,
+    decay,
+    parallel,
+    sequence,
+    stagger,
+    loop,
+    delay,
+    add,
+    subtract,
+    multiply,
+    divide,
+    modulo,
+    diffClamp,
+    event,
+    forkEvent,
+    unforkEvent,
+};
+// RN swaps the WHOLE driver namespace for the mock when the host reports isDisableAnimations
+// (reduced motion / test env): the mock keeps the same surface but jumps each animation to its
+// final value synchronously, no frames. The animated COMPONENTS are live in both branches; only
+// the drivers/value/operators/events half is swapped, exactly like RN spreading `...Animated`
+// (impl or mock) over the same components.
+const drivers = Platform.isDisableAnimations ? AnimatedMock : liveDrivers;
+export const Animated = {
+    View: AnimatedView,
+    Text: AnimatedText,
+    Image: AnimatedImage,
+    ScrollView: AnimatedScrollView,
+    FlatList: AnimatedFlatList,
+    SectionList: AnimatedSectionList,
+    createAnimatedComponent,
+    ...drivers,
+};

package/build/modules/app-registry/index.d.ts

@@ -0,0 +1,7 @@
+import type { Type } from '@angular/core';
+import { type IAppParameters } from '@symbiote-native/engine';
+export type IComponentProvider = () => Type<unknown>;
+export type IWrapperComponentProvider = (appParameters: IAppParameters) => Type<unknown>;
+declare const AppRegistry: import("@symbiote-native/engine").IAppRegistry<IComponentProvider, IWrapperComponentProvider>, setHostRegistrar: (registrar: import("@symbiote-native/engine").IHostRegistrar) => void;
+export { AppRegistry, setHostRegistrar };
+export type { IAppParameters, IRunnable, IHostRegistrar, IRegistry, IHeadlessTask, ITaskProvider, ITaskCanceller, ITaskCancelProvider, } from '@symbiote-native/engine';

package/build/modules/app-registry/index.js

@@ -0,0 +1,22 @@
+// AppRegistry: the JS entry point RN apps already use:
+//   AppRegistry.registerComponent(appKey, () => App)
+// The registry bookkeeping (sections, host-registrar bridge, headless tasks) is
+// framework-agnostic and lives in @symbiote-native/engine's createAppRegistry; this file supplies
+// only the one Angular-specific seam — building a runnable from a component provider via
+// `mount`'s wrapper/initialProps support (render.ts) — so examples/angular's own
+// registerRunnable + mount call can move onto the same entry point React/Vue already have.
+import { createAppRegistry, dlog, } from '@symbiote-native/engine';
+import { mount } from '../../render';
+function runnableFor(componentProvider, getWrapperComponentProvider) {
+    return appParameters => {
+        dlog(`AppRegistry: mounting on rootTag ${String(appParameters.rootTag)}`);
+        // Read live (not at registration time) so setWrapperComponentProvider affects every
+        // runnable's next run, not just future ones.
+        mount(appParameters.rootTag, componentProvider(), {
+            initialProps: appParameters.initialProps,
+            wrapperComponent: getWrapperComponentProvider()?.(appParameters),
+        });
+    };
+}
+const { AppRegistry, setHostRegistrar } = createAppRegistry(runnableFor);
+export { AppRegistry, setHostRegistrar };

package/build/modules/status-bar.d.ts

@@ -0,0 +1,17 @@
+import { type OnChanges, type SimpleChanges } from '@angular/core';
+import { type IColorValue, type IStatusBarStyle } from '@symbiote-native/engine';
+export type { IStatusBarProps, IStatusBarStyle } from '@symbiote-native/engine';
+declare class StatusBarComponent implements OnChanges {
+    barStyle?: IStatusBarStyle;
+    hidden?: boolean;
+    animated?: boolean;
+    networkActivityIndicatorVisible?: boolean;
+    backgroundColor?: IColorValue;
+    translucent?: boolean;
+    ngOnChanges(_changes: SimpleChanges): void;
+    private buildProps;
+}
+declare const StatusBarWithStatics: typeof StatusBarComponent & import("@symbiote-native/engine").IStatusBarImperative;
+export declare const StatusBar: typeof StatusBarWithStatics & {
+    readonly currentHeight?: number;
+};

package/build/modules/status-bar.js

@@ -0,0 +1,121 @@
+// StatusBar, the Angular lifecycle half. The native StatusBarManager driving, the imperative
+// statics, and the Android bar-height constant all live in @symbiote-native/engine, shared verbatim with
+// React and Vue; Metro selects the engine's platform variant. Angular supplies only the
+// declarative shape: a component that renders nothing and re-applies the props through
+// ngOnChanges on mount + every prop change. Imperative statics are attached to the component
+// object the same way RN does.
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { Component, Input } from '@angular/core';
+import { applyStatusBarProps, statusBarImperative, statusBarCurrentHeight, } from '@symbiote-native/engine';
+let StatusBarComponent = (() => {
+    let _classDecorators = [Component({
+            selector: 'StatusBar',
+            standalone: true,
+            template: '',
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _barStyle_decorators;
+    let _barStyle_initializers = [];
+    let _barStyle_extraInitializers = [];
+    let _hidden_decorators;
+    let _hidden_initializers = [];
+    let _hidden_extraInitializers = [];
+    let _animated_decorators;
+    let _animated_initializers = [];
+    let _animated_extraInitializers = [];
+    let _networkActivityIndicatorVisible_decorators;
+    let _networkActivityIndicatorVisible_initializers = [];
+    let _networkActivityIndicatorVisible_extraInitializers = [];
+    let _backgroundColor_decorators;
+    let _backgroundColor_initializers = [];
+    let _backgroundColor_extraInitializers = [];
+    let _translucent_decorators;
+    let _translucent_initializers = [];
+    let _translucent_extraInitializers = [];
+    var StatusBarComponent = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _barStyle_decorators = [Input()];
+            _hidden_decorators = [Input()];
+            _animated_decorators = [Input()];
+            _networkActivityIndicatorVisible_decorators = [Input()];
+            _backgroundColor_decorators = [Input()];
+            _translucent_decorators = [Input()];
+            __esDecorate(null, null, _barStyle_decorators, { kind: "field", name: "barStyle", static: false, private: false, access: { has: obj => "barStyle" in obj, get: obj => obj.barStyle, set: (obj, value) => { obj.barStyle = value; } }, metadata: _metadata }, _barStyle_initializers, _barStyle_extraInitializers);
+            __esDecorate(null, null, _hidden_decorators, { kind: "field", name: "hidden", static: false, private: false, access: { has: obj => "hidden" in obj, get: obj => obj.hidden, set: (obj, value) => { obj.hidden = value; } }, metadata: _metadata }, _hidden_initializers, _hidden_extraInitializers);
+            __esDecorate(null, null, _animated_decorators, { kind: "field", name: "animated", static: false, private: false, access: { has: obj => "animated" in obj, get: obj => obj.animated, set: (obj, value) => { obj.animated = value; } }, metadata: _metadata }, _animated_initializers, _animated_extraInitializers);
+            __esDecorate(null, null, _networkActivityIndicatorVisible_decorators, { kind: "field", name: "networkActivityIndicatorVisible", static: false, private: false, access: { has: obj => "networkActivityIndicatorVisible" in obj, get: obj => obj.networkActivityIndicatorVisible, set: (obj, value) => { obj.networkActivityIndicatorVisible = value; } }, metadata: _metadata }, _networkActivityIndicatorVisible_initializers, _networkActivityIndicatorVisible_extraInitializers);
+            __esDecorate(null, null, _backgroundColor_decorators, { kind: "field", name: "backgroundColor", static: false, private: false, access: { has: obj => "backgroundColor" in obj, get: obj => obj.backgroundColor, set: (obj, value) => { obj.backgroundColor = value; } }, metadata: _metadata }, _backgroundColor_initializers, _backgroundColor_extraInitializers);
+            __esDecorate(null, null, _translucent_decorators, { kind: "field", name: "translucent", static: false, private: false, access: { has: obj => "translucent" in obj, get: obj => obj.translucent, set: (obj, value) => { obj.translucent = value; } }, metadata: _metadata }, _translucent_initializers, _translucent_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            StatusBarComponent = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        barStyle = __runInitializers(this, _barStyle_initializers, void 0);
+        hidden = (__runInitializers(this, _barStyle_extraInitializers), __runInitializers(this, _hidden_initializers, void 0));
+        animated = (__runInitializers(this, _hidden_extraInitializers), __runInitializers(this, _animated_initializers, void 0));
+        networkActivityIndicatorVisible = (__runInitializers(this, _animated_extraInitializers), __runInitializers(this, _networkActivityIndicatorVisible_initializers, void 0));
+        backgroundColor = (__runInitializers(this, _networkActivityIndicatorVisible_extraInitializers), __runInitializers(this, _backgroundColor_initializers, void 0));
+        translucent = (__runInitializers(this, _backgroundColor_extraInitializers), __runInitializers(this, _translucent_initializers, void 0));
+        ngOnChanges(_changes) {
+            applyStatusBarProps(this.buildProps());
+        }
+        buildProps() {
+            return {
+                barStyle: this.barStyle,
+                hidden: this.hidden,
+                animated: this.animated,
+                networkActivityIndicatorVisible: this.networkActivityIndicatorVisible,
+                backgroundColor: this.backgroundColor,
+                translucent: this.translucent,
+            };
+        }
+        constructor() {
+            __runInitializers(this, _translucent_extraInitializers);
+        }
+    };
+    return StatusBarComponent = _classThis;
+})();
+const StatusBarWithStatics = Object.assign(StatusBarComponent, statusBarImperative);
+Object.defineProperty(StatusBarWithStatics, 'currentHeight', {
+    get: statusBarCurrentHeight,
+    enumerable: true,
+});
+export const StatusBar = StatusBarWithStatics;

package/build/primitives/index.d.ts

@@ -0,0 +1,32 @@
+import { SymbiotePrimitiveHost } from './shared';
+export { anchorHostStyle, anchorStyleProp, stableAnchorStyle, SymbioteHostPropsDirective, } from './shared';
+export declare class ViewHost extends SymbiotePrimitiveHost {
+}
+export declare class TextHost extends SymbiotePrimitiveHost {
+}
+export declare class ImageHost extends SymbiotePrimitiveHost {
+}
+export declare class ScrollViewHost extends SymbiotePrimitiveHost {
+}
+export declare class ScrollContentView extends SymbiotePrimitiveHost {
+}
+export declare class HorizontalScrollView extends SymbiotePrimitiveHost {
+}
+export declare class HorizontalScrollContentView extends SymbiotePrimitiveHost {
+}
+export declare class TextInputHost extends SymbiotePrimitiveHost {
+}
+export declare class MultilineTextInputHost extends SymbiotePrimitiveHost {
+}
+export declare class SwitchHost extends SymbiotePrimitiveHost {
+}
+export declare class ActivityIndicatorHost extends SymbiotePrimitiveHost {
+}
+export declare class SafeAreaViewHost extends SymbiotePrimitiveHost {
+}
+export declare class ModalHost extends SymbiotePrimitiveHost {
+}
+export declare class RefreshControlHost extends SymbiotePrimitiveHost {
+}
+export declare class InputAccessoryViewHost extends SymbiotePrimitiveHost {
+}