@symbiote-native/angular 0.1.0

package/build/components/drawer-layout-android/shared.js

@@ -0,0 +1,205 @@
+// Shared types + the input-field base for the Angular DrawerLayoutAndroid: the Props/Handle
+// contract both the real Android build (index.android.ts) and the off-Android fallback (index.ts)
+// implement. The platform-agnostic enums + the imperative handle live in @symbiote/components
+// (shared verbatim with React/Vue, the single source of truth); this file adds only the
+// Angular-facing prop surface. Per ADR 0019 the filename selects the build; no Platform.OS read
+// anywhere. The Angular twin of the Vue folder's shared.ts, with the bulky @Input field block
+// pulled into a base class both builds extend (the Switch SwitchBase precedent), so the input
+// surface is declared once. The `inputs:` array itself stays an inline literal per @Component
+// (ngc AOT needs a static literal, so it cannot be hoisted into a shared const).
+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 { Directive, EventEmitter, Output } from '@angular/core';
+// The shared @Input/@Output field block. The concrete @Component lists the matching `inputs:`
+// array (the SwitchBase pattern) for plain inputs, plus `outputs:` for the events below. Aria props
+// use their literal kebab names so a field directly satisfies the optional IAriaProps member and is
+// its own input name (no alias bookkeeping). accessibilityInputs() folds the whole bag for
+// resolveAccessibilityProps, the way Modal's does. @Directive() is required the moment this base
+// carries decorated members (@Output() here) — ngc's AOT build (NG2007) enforces it, mirroring
+// ScrollViewBase/SwitchBase.
+let DrawerLayoutAndroidBase = (() => {
+    let _classDecorators = [Directive()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _drawerOpen_decorators;
+    let _drawerOpen_initializers = [];
+    let _drawerOpen_extraInitializers = [];
+    let _drawerClose_decorators;
+    let _drawerClose_initializers = [];
+    let _drawerClose_extraInitializers = [];
+    let _drawerSlide_decorators;
+    let _drawerSlide_initializers = [];
+    let _drawerSlide_extraInitializers = [];
+    let _drawerStateChanged_decorators;
+    let _drawerStateChanged_initializers = [];
+    let _drawerStateChanged_extraInitializers = [];
+    let _accessibilityAction_decorators;
+    let _accessibilityAction_initializers = [];
+    let _accessibilityAction_extraInitializers = [];
+    let _accessibilityTap_decorators;
+    let _accessibilityTap_initializers = [];
+    let _accessibilityTap_extraInitializers = [];
+    let _magicTap_decorators;
+    let _magicTap_initializers = [];
+    let _magicTap_extraInitializers = [];
+    let _accessibilityEscape_decorators;
+    let _accessibilityEscape_initializers = [];
+    let _accessibilityEscape_extraInitializers = [];
+    var DrawerLayoutAndroidBase = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _drawerOpen_decorators = [Output()];
+            _drawerClose_decorators = [Output()];
+            _drawerSlide_decorators = [Output()];
+            _drawerStateChanged_decorators = [Output()];
+            _accessibilityAction_decorators = [Output()];
+            _accessibilityTap_decorators = [Output()];
+            _magicTap_decorators = [Output()];
+            _accessibilityEscape_decorators = [Output()];
+            __esDecorate(null, null, _drawerOpen_decorators, { kind: "field", name: "drawerOpen", static: false, private: false, access: { has: obj => "drawerOpen" in obj, get: obj => obj.drawerOpen, set: (obj, value) => { obj.drawerOpen = value; } }, metadata: _metadata }, _drawerOpen_initializers, _drawerOpen_extraInitializers);
+            __esDecorate(null, null, _drawerClose_decorators, { kind: "field", name: "drawerClose", static: false, private: false, access: { has: obj => "drawerClose" in obj, get: obj => obj.drawerClose, set: (obj, value) => { obj.drawerClose = value; } }, metadata: _metadata }, _drawerClose_initializers, _drawerClose_extraInitializers);
+            __esDecorate(null, null, _drawerSlide_decorators, { kind: "field", name: "drawerSlide", static: false, private: false, access: { has: obj => "drawerSlide" in obj, get: obj => obj.drawerSlide, set: (obj, value) => { obj.drawerSlide = value; } }, metadata: _metadata }, _drawerSlide_initializers, _drawerSlide_extraInitializers);
+            __esDecorate(null, null, _drawerStateChanged_decorators, { kind: "field", name: "drawerStateChanged", static: false, private: false, access: { has: obj => "drawerStateChanged" in obj, get: obj => obj.drawerStateChanged, set: (obj, value) => { obj.drawerStateChanged = value; } }, metadata: _metadata }, _drawerStateChanged_initializers, _drawerStateChanged_extraInitializers);
+            __esDecorate(null, null, _accessibilityAction_decorators, { kind: "field", name: "accessibilityAction", static: false, private: false, access: { has: obj => "accessibilityAction" in obj, get: obj => obj.accessibilityAction, set: (obj, value) => { obj.accessibilityAction = value; } }, metadata: _metadata }, _accessibilityAction_initializers, _accessibilityAction_extraInitializers);
+            __esDecorate(null, null, _accessibilityTap_decorators, { kind: "field", name: "accessibilityTap", static: false, private: false, access: { has: obj => "accessibilityTap" in obj, get: obj => obj.accessibilityTap, set: (obj, value) => { obj.accessibilityTap = value; } }, metadata: _metadata }, _accessibilityTap_initializers, _accessibilityTap_extraInitializers);
+            __esDecorate(null, null, _magicTap_decorators, { kind: "field", name: "magicTap", static: false, private: false, access: { has: obj => "magicTap" in obj, get: obj => obj.magicTap, set: (obj, value) => { obj.magicTap = value; } }, metadata: _metadata }, _magicTap_initializers, _magicTap_extraInitializers);
+            __esDecorate(null, null, _accessibilityEscape_decorators, { kind: "field", name: "accessibilityEscape", static: false, private: false, access: { has: obj => "accessibilityEscape" in obj, get: obj => obj.accessibilityEscape, set: (obj, value) => { obj.accessibilityEscape = value; } }, metadata: _metadata }, _accessibilityEscape_initializers, _accessibilityEscape_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            DrawerLayoutAndroidBase = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        // The drawer/accessibility lifecycle as real Angular events: `(drawerOpen)="onOpen()"`, not
+        // `[onDrawerOpen]="onOpen"` — mirrors Pressable's press/hover @Output() conversion. The
+        // concrete @Component lists these SAME names in its `outputs:` array (the Switch precedent
+        // for a field declared on a shared base class rather than the concrete class itself).
+        drawerOpen = __runInitializers(this, _drawerOpen_initializers, new EventEmitter());
+        drawerClose = (__runInitializers(this, _drawerOpen_extraInitializers), __runInitializers(this, _drawerClose_initializers, new EventEmitter()));
+        drawerSlide = (__runInitializers(this, _drawerClose_extraInitializers), __runInitializers(this, _drawerSlide_initializers, new EventEmitter()));
+        drawerStateChanged = (__runInitializers(this, _drawerSlide_extraInitializers), __runInitializers(this, _drawerStateChanged_initializers, new EventEmitter()));
+        accessibilityAction = (__runInitializers(this, _drawerStateChanged_extraInitializers), __runInitializers(this, _accessibilityAction_initializers, new EventEmitter()));
+        accessibilityTap = (__runInitializers(this, _accessibilityAction_extraInitializers), __runInitializers(this, _accessibilityTap_initializers, new EventEmitter()));
+        magicTap = (__runInitializers(this, _accessibilityTap_extraInitializers), __runInitializers(this, _magicTap_initializers, new EventEmitter()));
+        accessibilityEscape = (__runInitializers(this, _magicTap_extraInitializers), __runInitializers(this, _accessibilityEscape_initializers, new EventEmitter()));
+        drawerWidth = __runInitializers(this, _accessibilityEscape_extraInitializers);
+        drawerPosition;
+        drawerLockMode;
+        keyboardDismissMode;
+        drawerBackgroundColor;
+        statusBarBackgroundColor;
+        style;
+        nativeID;
+        testID;
+        accessible;
+        accessibilityLabel;
+        accessibilityHint;
+        accessibilityRole;
+        accessibilityState;
+        accessibilityValue;
+        accessibilityActions;
+        accessibilityLabelledBy;
+        importantForAccessibility;
+        accessibilityLiveRegion;
+        screenReaderFocusable;
+        accessibilityElementsHidden;
+        accessibilityViewIsModal;
+        accessibilityIgnoresInvertColors;
+        accessibilityLanguage;
+        accessibilityRespondsToUserInteraction;
+        accessibilityShowsLargeContentViewer;
+        accessibilityLargeContentTitle;
+        role;
+        'aria-label';
+        'aria-labelledby';
+        'aria-live';
+        'aria-hidden';
+        'aria-busy';
+        'aria-checked';
+        'aria-disabled';
+        'aria-expanded';
+        'aria-selected';
+        'aria-modal';
+        'aria-valuemax';
+        'aria-valuemin';
+        'aria-valuenow';
+        'aria-valuetext';
+        // Typed as the a11y intersection WITH the string index (the bag resolveAccessibilityProps folds
+        // aria-*/role into the RN accessibility* names of), so its result stays assignable to the
+        // resolveDrawerLayout passthrough.
+        accessibilityInputs() {
+            return {
+                nativeID: this.nativeID,
+                testID: this.testID,
+                accessible: this.accessible,
+                accessibilityLabel: this.accessibilityLabel,
+                accessibilityHint: this.accessibilityHint,
+                accessibilityRole: this.accessibilityRole,
+                accessibilityState: this.accessibilityState,
+                accessibilityValue: this.accessibilityValue,
+                accessibilityActions: this.accessibilityActions,
+                accessibilityLabelledBy: this.accessibilityLabelledBy,
+                importantForAccessibility: this.importantForAccessibility,
+                accessibilityLiveRegion: this.accessibilityLiveRegion,
+                screenReaderFocusable: this.screenReaderFocusable,
+                accessibilityElementsHidden: this.accessibilityElementsHidden,
+                accessibilityViewIsModal: this.accessibilityViewIsModal,
+                accessibilityIgnoresInvertColors: this.accessibilityIgnoresInvertColors,
+                accessibilityLanguage: this.accessibilityLanguage,
+                accessibilityRespondsToUserInteraction: this.accessibilityRespondsToUserInteraction,
+                accessibilityShowsLargeContentViewer: this.accessibilityShowsLargeContentViewer,
+                accessibilityLargeContentTitle: this.accessibilityLargeContentTitle,
+                role: this.role,
+                'aria-label': this['aria-label'],
+                'aria-labelledby': this['aria-labelledby'],
+                'aria-live': this['aria-live'],
+                'aria-hidden': this['aria-hidden'],
+                'aria-busy': this['aria-busy'],
+                'aria-checked': this['aria-checked'],
+                'aria-disabled': this['aria-disabled'],
+                'aria-expanded': this['aria-expanded'],
+                'aria-selected': this['aria-selected'],
+                'aria-modal': this['aria-modal'],
+                'aria-valuemax': this['aria-valuemax'],
+                'aria-valuemin': this['aria-valuemin'],
+                'aria-valuenow': this['aria-valuenow'],
+                'aria-valuetext': this['aria-valuetext'],
+            };
+        }
+    };
+    return DrawerLayoutAndroidBase = _classThis;
+})();
+export { DrawerLayoutAndroidBase };

package/build/components/flat-list/index.d.ts

@@ -0,0 +1,119 @@
+import { EventEmitter, type OnChanges, type SimpleChanges } from '@angular/core';
+import { type IRow, type IScrollViewHandle, type IViewabilityConfigCallbackPair, type IViewableItemsChangedInfo, type IVirtualizedListHandle } from '@symbiote-native/components';
+import { type IStyleProp, type ISymbioteNode, type IViewStyle } from '@symbiote-native/engine';
+import { VListEmptyDirective, VListFooterDirective, VListHeaderDirective, VListItemDirective, VListSeparatorDirective, type IVirtualizedListProps, type IVListItemContext, type IVListSeparatorContext } from '../virtualized-list';
+export type { ISeparators, IViewableItemsChangedInfo, IViewabilityConfigCallbackPair, IVirtualizedListHandle, } from '@symbiote-native/components';
+export { VListEmptyDirective, VListFooterDirective, VListHeaderDirective, VListItemDirective, VListSeparatorDirective, } from '../virtualized-list';
+export type { IVListItemContext, IVListSeparatorContext } from '../virtualized-list';
+export type IFlatListHandle = IVirtualizedListHandle;
+export type IFlatListProps<ItemT> = Omit<IVirtualizedListProps<ItemT>, 'data' | 'getItem' | 'getItemCount'> & {
+    data: readonly ItemT[];
+    numColumns?: number;
+    columnWrapperStyle?: IStyleProp<IViewStyle> | string;
+};
+export type IFlatListInputs<ItemT> = Omit<IFlatListProps<ItemT>, 'onEndReached' | 'onStartReached' | 'onRefresh' | 'onViewableItemsChanged' | 'onScrollToIndexFailed'>;
+export declare class FlatList<ItemT = unknown> implements IFlatListInputs<ItemT>, IVirtualizedListHandle, OnChanges {
+    readonly endReached: EventEmitter<{
+        distanceFromEnd: number;
+    }>;
+    readonly startReached: EventEmitter<{
+        distanceFromStart: number;
+    }>;
+    readonly refresh: EventEmitter<void>;
+    readonly viewableItemsChanged: EventEmitter<IViewableItemsChangedInfo<ItemT>>;
+    readonly scrollToIndexFailed: EventEmitter<{
+        index: number;
+        highestMeasuredFrameIndex: number;
+        averageItemLength: number;
+    }>;
+    data: readonly ItemT[];
+    numColumns?: number;
+    columnWrapperStyle?: IStyleProp<IViewStyle> | string;
+    keyExtractor?: (item: ItemT, index: number) => string;
+    getItemLayout?: (data: unknown, index: number) => {
+        length: number;
+        offset: number;
+        index: number;
+    };
+    horizontal?: boolean;
+    inverted?: boolean;
+    extraData?: unknown;
+    onEndReachedThreshold?: number;
+    onStartReachedThreshold?: number;
+    refreshing?: boolean | null;
+    progressViewOffset?: number;
+    viewabilityConfig?: IVirtualizedListProps<ItemT>['viewabilityConfig'];
+    viewabilityConfigCallbackPairs?: IViewabilityConfigCallbackPair<ItemT>[];
+    initialNumToRender?: number;
+    initialScrollIndex?: number;
+    maxToRenderPerBatch?: number;
+    updateCellsBatchingPeriod?: number;
+    windowSize?: number;
+    stickyHeaderIndices?: number[];
+    maintainVisibleContentPosition?: {
+        minIndexForVisible: number;
+        autoscrollToTopThreshold?: number;
+    };
+    onScroll?: IVirtualizedListProps<ItemT>['onScroll'];
+    onScrollBeginDrag?: IVirtualizedListProps<ItemT>['onScrollBeginDrag'];
+    onScrollEndDrag?: IVirtualizedListProps<ItemT>['onScrollEndDrag'];
+    onMomentumScrollBegin?: IVirtualizedListProps<ItemT>['onMomentumScrollBegin'];
+    onMomentumScrollEnd?: IVirtualizedListProps<ItemT>['onMomentumScrollEnd'];
+    scrollEventThrottle?: number;
+    keyboardShouldPersistTaps?: boolean | 'always' | 'never' | 'handled';
+    keyboardDismissMode?: 'none' | 'on-drag' | 'interactive';
+    style?: IStyleProp<IViewStyle>;
+    contentContainerStyle?: IStyleProp<IViewStyle>;
+    itemDir?: VListItemDirective<ItemT>;
+    headerDir?: VListHeaderDirective;
+    footerDir?: VListFooterDirective;
+    emptyDir?: VListEmptyDirective;
+    separatorDir?: VListSeparatorDirective<ItemT>;
+    private listRef?;
+    private readonly elementRef;
+    rows: IRow<ItemT>[];
+    rowStyle: IViewStyle;
+    rowViewabilityPairs?: IViewabilityConfigCallbackPair<IRow<ItemT>>[];
+    readonly columnCellStyle: IViewStyle;
+    resolvedStyle: IViewStyle | undefined;
+    get columns(): number;
+    get isMultiColumn(): boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    getFlatItem: (_data: unknown, index: number) => ItemT;
+    getFlatCount: (_data: unknown) => number;
+    getRow: (_data: unknown, index: number) => IRow<ItemT>;
+    getRowCount: (_data: unknown) => number;
+    rowKey: (row: IRow<ItemT>, _index: number) => string;
+    rowViewableItemsChanged: (info: IViewableItemsChangedInfo<IRow<ItemT>>) => void;
+    private buildRowViewabilityPairs;
+    rowCells(row: unknown, separators: unknown): {
+        key: string;
+        context: IVListItemContext<ItemT>;
+    }[];
+    rowSeparatorContext(highlighted: unknown, leadingRow: unknown, trailingRow: unknown): IVListSeparatorContext<ItemT>;
+    itemSeparatorContext(highlighted: unknown, leadingItem: unknown, trailingItem: unknown): IVListSeparatorContext<ItemT>;
+    scrollToOffset(params: {
+        offset: number;
+        animated?: boolean;
+    }): void;
+    scrollToIndex(params: {
+        index: number;
+        animated?: boolean;
+        viewOffset?: number;
+        viewPosition?: number;
+    }): void;
+    scrollToItem(params: {
+        item: unknown;
+        animated?: boolean;
+        viewPosition?: number;
+    }): void;
+    scrollToEnd(params?: {
+        animated?: boolean;
+    }): void;
+    flashScrollIndicators(): void;
+    getNativeScrollRef(): IScrollViewHandle | null;
+    getScrollableNode(): IScrollViewHandle | null;
+    getScrollResponder(): IScrollViewHandle | null;
+    getScrollNode(): ISymbioteNode | null;
+    recordInteraction(): void;
+}