@symbiote-native/angular 0.1.0

package/build/primitives/index.js

@@ -0,0 +1,386 @@
+// Angular primitive host components over Symbiote engine intrinsics. These are the only
+// components that directly own the `symbiote-*` selectors; every composed adapter
+// component imports them and renders them in its template. Declaring `style` as a real
+// Angular input prevents Angular's CSS style engine from decomposing RN `StyleProp` arrays.
+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 } from '@angular/core';
+import { SymbiotePrimitiveHost } from './shared';
+export { anchorHostStyle, anchorStyleProp, stableAnchorStyle, SymbioteHostPropsDirective, } from './shared';
+let ViewHost = (() => {
+    let _classDecorators = [Component({
+            selector: 'symbiote-view, View',
+            standalone: true,
+            template: '<ng-content></ng-content>',
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = SymbiotePrimitiveHost;
+    var ViewHost = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ViewHost = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ViewHost = _classThis;
+})();
+export { ViewHost };
+let TextHost = (() => {
+    let _classDecorators = [Component({
+            selector: 'symbiote-text, Text',
+            standalone: true,
+            template: '<ng-content></ng-content>',
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = SymbiotePrimitiveHost;
+    var TextHost = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            TextHost = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return TextHost = _classThis;
+})();
+export { TextHost };
+let ImageHost = (() => {
+    let _classDecorators = [Component({
+            selector: 'symbiote-image',
+            standalone: true,
+            template: '<ng-content></ng-content>',
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = SymbiotePrimitiveHost;
+    var ImageHost = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ImageHost = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ImageHost = _classThis;
+})();
+export { ImageHost };
+let ScrollViewHost = (() => {
+    let _classDecorators = [Component({
+            selector: 'symbiote-scroll-view',
+            standalone: true,
+            template: '<ng-content></ng-content>',
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = SymbiotePrimitiveHost;
+    var ScrollViewHost = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ScrollViewHost = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ScrollViewHost = _classThis;
+})();
+export { ScrollViewHost };
+let ScrollContentView = (() => {
+    let _classDecorators = [Component({
+            selector: 'symbiote-scroll-content',
+            standalone: true,
+            template: '<ng-content></ng-content>',
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = SymbiotePrimitiveHost;
+    var ScrollContentView = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ScrollContentView = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ScrollContentView = _classThis;
+})();
+export { ScrollContentView };
+let HorizontalScrollView = (() => {
+    let _classDecorators = [Component({
+            selector: 'symbiote-horizontal-scroll-view',
+            standalone: true,
+            template: '<ng-content></ng-content>',
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = SymbiotePrimitiveHost;
+    var HorizontalScrollView = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            HorizontalScrollView = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return HorizontalScrollView = _classThis;
+})();
+export { HorizontalScrollView };
+let HorizontalScrollContentView = (() => {
+    let _classDecorators = [Component({
+            selector: 'symbiote-horizontal-scroll-content',
+            standalone: true,
+            template: '<ng-content></ng-content>',
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = SymbiotePrimitiveHost;
+    var HorizontalScrollContentView = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            HorizontalScrollContentView = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return HorizontalScrollContentView = _classThis;
+})();
+export { HorizontalScrollContentView };
+let TextInputHost = (() => {
+    let _classDecorators = [Component({
+            selector: 'symbiote-text-input',
+            standalone: true,
+            template: '<ng-content></ng-content>',
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = SymbiotePrimitiveHost;
+    var TextInputHost = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            TextInputHost = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return TextInputHost = _classThis;
+})();
+export { TextInputHost };
+let MultilineTextInputHost = (() => {
+    let _classDecorators = [Component({
+            selector: 'symbiote-text-input-multiline',
+            standalone: true,
+            template: '<ng-content></ng-content>',
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = SymbiotePrimitiveHost;
+    var MultilineTextInputHost = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            MultilineTextInputHost = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return MultilineTextInputHost = _classThis;
+})();
+export { MultilineTextInputHost };
+let SwitchHost = (() => {
+    let _classDecorators = [Component({
+            selector: 'symbiote-switch',
+            standalone: true,
+            template: '<ng-content></ng-content>',
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = SymbiotePrimitiveHost;
+    var SwitchHost = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            SwitchHost = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return SwitchHost = _classThis;
+})();
+export { SwitchHost };
+let ActivityIndicatorHost = (() => {
+    let _classDecorators = [Component({
+            selector: 'symbiote-activity-indicator',
+            standalone: true,
+            template: '<ng-content></ng-content>',
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = SymbiotePrimitiveHost;
+    var ActivityIndicatorHost = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ActivityIndicatorHost = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ActivityIndicatorHost = _classThis;
+})();
+export { ActivityIndicatorHost };
+let SafeAreaViewHost = (() => {
+    let _classDecorators = [Component({
+            selector: 'symbiote-safe-area-view',
+            standalone: true,
+            template: '<ng-content></ng-content>',
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = SymbiotePrimitiveHost;
+    var SafeAreaViewHost = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            SafeAreaViewHost = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return SafeAreaViewHost = _classThis;
+})();
+export { SafeAreaViewHost };
+let ModalHost = (() => {
+    let _classDecorators = [Component({
+            selector: 'symbiote-modal',
+            standalone: true,
+            template: '<ng-content></ng-content>',
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = SymbiotePrimitiveHost;
+    var ModalHost = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ModalHost = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ModalHost = _classThis;
+})();
+export { ModalHost };
+let RefreshControlHost = (() => {
+    let _classDecorators = [Component({
+            selector: 'symbiote-refresh-control',
+            standalone: true,
+            template: '<ng-content></ng-content>',
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = SymbiotePrimitiveHost;
+    var RefreshControlHost = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            RefreshControlHost = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return RefreshControlHost = _classThis;
+})();
+export { RefreshControlHost };
+let InputAccessoryViewHost = (() => {
+    let _classDecorators = [Component({
+            selector: 'symbiote-input-accessory-view',
+            standalone: true,
+            template: '<ng-content></ng-content>',
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = SymbiotePrimitiveHost;
+    var InputAccessoryViewHost = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            InputAccessoryViewHost = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return InputAccessoryViewHost = _classThis;
+})();
+export { InputAccessoryViewHost };

package/build/primitives/shared.d.ts

@@ -0,0 +1,84 @@
+import { ElementRef, type OnChanges, type SimpleChanges } from '@angular/core';
+import { type IHostInstance, type IStyleProp } from '@symbiote-native/engine';
+/**
+ * A composed Angular component (Pressable, SafeAreaView, ScrollView, ...) is created as a
+ * non-painting ANCHOR host (`ANCHOR_HOST_COMPONENTS` in renderer.ts) so it doesn't paint an
+ * extra native view over its own template's real content. `class="..."`/`[class.x]`/`[ngClass]`
+ * at the component's use site ALWAYS resolves through the renderer's addClass/removeClass onto
+ * that anchor — Angular gives no `@Input()` interception hook for `class` the way it does for
+ * `[style]` (which is why `style` alone was declared as an `@Input()` in the first place, see
+ * `SymbiotePrimitiveHost` above) — so the anchor ends up holding the fully-resolved class-derived
+ * style (`routeProp`'s `commitClassStyle` already wrote it to `anchor.props.style`) while the
+ * REAL native node the component's own template creates never sees it.
+ *
+ * Call this from a composed component's own `hostProps`/style getter and merge the result AHEAD
+ * of its own explicit `style` @Input, e.g. `style: [anchorHostStyle(this.elementRef),
+ * this.resolvedStyle]` — array order matters: `flattenStyle`'s later-wins collapse is what makes
+ * an explicit `[style]` on the component still beat its ambient class, mirroring the
+ * class-loses-to-explicit-style cascade `commitClassStyle` already enforces for a direct
+ * primitive. `this.elementRef` must be this component's OWN injected `ElementRef` (its anchor
+ * host), not a `@ViewChild` into its template's inner primitive.
+ *
+ * Skipping this call for a new `ANCHOR_HOST_COMPONENTS` entry compiles clean under `tsc` AND a
+ * real `ngc` AOT build — no type error, no template error — it just silently drops `class="..."`
+ * forever; only a device/simulator render (or a committed-node style assertion) catches it. See
+ * the `angular-adapter` skill §21 for the device-confirmed incident and the full checklist.
+ */
+export declare function anchorHostStyle(elementRef: ElementRef<unknown>): unknown;
+export declare function anchorStyleProp<T>(elementRef: ElementRef<unknown>): IStyleProp<T> | undefined;
+/**
+ * `anchorHostStyle` must be re-read on every check (a bare `class="x"` with no matching
+ * `[style]` binding never appears in Angular's `SimpleChanges`/dirty-check inputs, so nothing
+ * else signals "the anchor's class-derived style may have changed"). But `flattenStyle([...])`
+ * always allocates a FRESH object, even when its content is byte-for-byte identical to last
+ * time — and a windowed list component (FlatList/VirtualizedList/SectionList/
+ * VirtualizedSectionList) binds its resolved style into a structural-directive-bound `@Input()`
+ * chain where a fresh reference on an UNRELATED CD pass is mistaken for a real change, which
+ * reschedules ANOTHER CD tick (`VListOutletDirective`'s `context` `@Input()` calling
+ * `markForCheck()`) — free-running forever. See the `flat-list-array-style.test.ts` regression
+ * this fixes (and the near-identical `lastRecompute` dedup guard in `virtualized-list/index.ts`,
+ * which this mirrors at the style-merge call site instead of a whole recompute step). Returns
+ * `previous` unchanged when the freshly-flattened merge is shallow-equal to it, so a downstream
+ * `@Input() style` binding sees NO change and skips its own update on an unrelated tick.
+ */
+export declare function stableAnchorStyle(elementRef: ElementRef<unknown>, explicitStyle: unknown, previous: unknown): Record<string, unknown>;
+/**
+ * Base for all Angular primitive host components (`symbiote-view`, `symbiote-text`, ...).
+ * RN's `StyleProp` can be an object, an array, nested arrays, falsy entries, and Animated
+ * values. Angular's raw `[style]` binding on a custom element routes through the CSS style
+ * engine (`setStyle` per key), which crashes on numeric array keys. By declaring `style` as
+ * an Angular `@Input()` on a known component, we intercept it here and forward a flattened
+ * style object through `Renderer2.setProperty`, bypassing Angular's CSS styling path.
+ *
+ * Other props (source, pointerEvents, ...) are intentionally *not* declared as inputs.
+ * Angular then treats them as host property bindings and still dispatches them through the
+ * custom renderer's `setProperty`, so the engine's `routeProp` handles them as usual.
+ */
+export declare abstract class SymbiotePrimitiveHost implements OnChanges {
+    private readonly renderer;
+    private readonly elementRef;
+    style?: IStyleProp<unknown>;
+    /**
+     * The underlying engine host node (public instance). Exposed so `findNodeHandle` can resolve
+     * an Angular template ref (`#ref`) on a primitive host to its native reactTag.
+     */
+    get nativeElement(): IHostInstance;
+    ngOnChanges(changes: SimpleChanges): void;
+}
+/**
+ * Applies a whole resolved props record (a shared `renderX(...).props` bag) onto a host
+ * element via `Renderer2.setProperty`, one call per key. Angular templates compile bindings
+ * ahead of time — there is no `v-bind="obj"` equivalent for a custom element — so a component
+ * whose props come from a shared render function would otherwise have to declare every key as
+ * its own static `[prop]="hostProps['x']"` binding. This generalizes the pattern
+ * `SwitchHostPropsDirective` proved first: `<symbiote-x [symbioteHostProps]="hostProps" #ref="symbioteHost">`,
+ * with `ref.node` exposing the native element for any imperative follow-up call.
+ */
+export declare class SymbioteHostPropsDirective {
+    private readonly renderer;
+    private readonly elementRef;
+    private readonly cdr;
+    get node(): unknown;
+    set symbioteHostProps(props: Record<string, unknown>);
+    private wrapCallback;
+}