@symbiote-native/angular 0.6.0 → 0.6.2

package/build/primitives/shared.js

@@ -1,230 +0,0 @@
-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 { ChangeDetectorRef, Directive, ElementRef, inject, Input, Renderer2, } from '@angular/core';
-import { flattenStyle, isSymbioteNode, } 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.
- */
-export function anchorHostStyle(elementRef) {
-    const node = elementRef.nativeElement;
-    return isSymbioteNode(node) ? node.props.style : undefined;
-}
-// anchorHostStyle returns `unknown` (it reads whatever already resolved onto the anchor node's
-// props bag); a style prop's fields are all optional so any object structurally satisfies it —
-// this narrows just enough (falsy-per-IStyleProp, or an object/array) to fold it into a
-// strictly-typed IStyleProp<T> array without an `as` cast, for a composed component whose own
-// inner primitive declares a real `@Input() style: IStyleProp<SomeConcreteStyle>` (e.g.
-// TouchableOpacity's Pressable, Button's TouchableOpacity) rather than the loosely-typed
-// `symbioteHostProps` bag most composed components merge anchorHostStyle into directly.
-function isStyleValue(value) {
-    return (value === undefined ||
-        value === null ||
-        value === false ||
-        value === '' ||
-        typeof value === 'object');
-}
-export function anchorStyleProp(elementRef) {
-    const value = anchorHostStyle(elementRef);
-    return isStyleValue(value) ? value : undefined;
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-function shallowStyleEqual(a, b) {
-    const aKeys = Object.keys(a);
-    if (aKeys.length !== Object.keys(b).length)
-        return false;
-    return aKeys.every(key => a[key] === b[key]);
-}
-/**
- * `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 function stableAnchorStyle(elementRef, explicitStyle, previous) {
-    const next = flattenStyle([anchorHostStyle(elementRef), explicitStyle]);
-    return isRecord(previous) && shallowStyleEqual(previous, next) ? previous : next;
-}
-const ON_PREFIX = /^on[A-Z]/;
-/**
- * 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.
- */
-let SymbiotePrimitiveHost = (() => {
-    let _classDecorators = [Directive()];
-    let _classDescriptor;
-    let _classExtraInitializers = [];
-    let _classThis;
-    let _style_decorators;
-    let _style_initializers = [];
-    let _style_extraInitializers = [];
-    var SymbiotePrimitiveHost = class {
-        static { _classThis = this; }
-        static {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _style_decorators = [Input()];
-            __esDecorate(null, null, _style_decorators, { kind: "field", name: "style", static: false, private: false, access: { has: obj => "style" in obj, get: obj => obj.style, set: (obj, value) => { obj.style = value; } }, metadata: _metadata }, _style_initializers, _style_extraInitializers);
-            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-            SymbiotePrimitiveHost = _classThis = _classDescriptor.value;
-            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            __runInitializers(_classThis, _classExtraInitializers);
-        }
-        renderer = inject(Renderer2);
-        elementRef = inject(ElementRef);
-        style = __runInitializers(this, _style_initializers, void 0);
-        /**
-         * 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() {
-            return this.elementRef.nativeElement;
-        }
-        ngOnChanges(changes) {
-            if (!('style' in changes))
-                return;
-            const value = this.style === undefined ? undefined : flattenStyle(this.style);
-            this.renderer.setProperty(this.elementRef.nativeElement, 'style', value);
-        }
-        constructor() {
-            __runInitializers(this, _style_extraInitializers);
-        }
-    };
-    return SymbiotePrimitiveHost = _classThis;
-})();
-export { SymbiotePrimitiveHost };
-/**
- * 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.
- */
-let SymbioteHostPropsDirective = (() => {
-    let _classDecorators = [Directive({
-            selector: '[symbioteHostProps]',
-            standalone: true,
-            exportAs: 'symbioteHost',
-            inputs: ['symbioteHostProps'],
-        })];
-    let _classDescriptor;
-    let _classExtraInitializers = [];
-    let _classThis;
-    var SymbioteHostPropsDirective = class {
-        static { _classThis = this; }
-        static {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-            SymbioteHostPropsDirective = _classThis = _classDescriptor.value;
-            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            __runInitializers(_classThis, _classExtraInitializers);
-        }
-        renderer = inject(Renderer2);
-        elementRef = inject(ElementRef);
-        // The directive lives in its HOST component's template, so its injected ChangeDetectorRef IS
-        // that component's own view detector — the one thing that can refresh it (see wrapCallback).
-        cdr = inject(ChangeDetectorRef);
-        get node() {
-            return this.elementRef.nativeElement;
-        }
-        set symbioteHostProps(props) {
-            for (const [key, value] of Object.entries(props)) {
-                this.renderer.setProperty(this.elementRef.nativeElement, key, this.wrapCallback(key, value));
-            }
-        }
-        // A flat-bag `onX` callback (responder negotiation, onLongPress, …) is invoked by the engine's
-        // event dispatch — a plain JS call, entirely outside Angular. In Angular 20 a component compiles
-        // as a SignalView (not CheckAlways), so a plain (non-signal) state mutation inside such a callback
-        // does NOT dirty the view's reactive consumer, and the scheduler's root detectChanges() will NOT
-        // descend into it (a Global pass only refreshes CheckAlways / Dirty / RefreshView views) — the
-        // "pan does nothing" bug on a nested component. `markForCheck()` flags THIS component's view AND
-        // all its ancestors with RefreshView (which survives the descent) and notifies the CD scheduler,
-        // so the next root tick repaints the mutation. It targets the directive's injecting view
-        // (`_cdRefInjectingView`, i.e. the host component), unlike `detectChanges()` which acts on a
-        // resolved `_lView` that is NOT the host component here. The Angular twin of what React/Vue get
-        // for free (setState / proxy reactivity).
-        wrapCallback(key, value) {
-            if (!ON_PREFIX.test(key) || typeof value !== 'function')
-                return value;
-            const handler = value;
-            return (...args) => {
-                const result = handler(...args);
-                this.cdr.markForCheck();
-                return result;
-            };
-        }
-    };
-    return SymbioteHostPropsDirective = _classThis;
-})();
-export { SymbioteHostPropsDirective };

package/build/render/index.d.ts

@@ -1,11 +0,0 @@
-import { type IRootTag, type SymbioteSurface } from '@symbiote-native/engine';
-import { type Type } from '@angular/core';
-export interface IMountOptions {
-    initialProps?: object;
-    wrapperComponent?: Type<unknown>;
-}
-export declare function mount(rootTag: IRootTag, rootComponent: Type<unknown>, options?: IMountOptions): SymbioteSurface;
-export declare function unmount(rootTag: IRootTag): void;
-declare global {
-    var RN$stopSurface: ((surfaceId: number) => void) | undefined;
-}

package/build/render/index.js

@@ -1,170 +0,0 @@
-// Mount an Angular app onto a Fabric surface. The native host hands us a rootTag; we
-// create a surface and bootstrap a standalone Angular component WITHOUT platform-browser
-// (no DOM) — createEnvironmentInjector + createComponent over @angular/core only, with our
-// SymbioteRendererFactory provided so Angular drives the engine, which commits into
-// nativeFabricUIManager; RN's own renderer never in the path. Angular twin of
-// adapters/vue/src/render.ts.
-import { createElement as createEngineElement, createSurface, disposeRoot, dlog, toPublicInstance, } from '@symbiote-native/engine';
-import { descriptorFor } from '@symbiote-native/components';
-import { ApplicationRef, createComponent, createEnvironmentInjector, DOCUMENT, ErrorHandler, RendererFactory2, ɵINJECTOR_SCOPE as INJECTOR_SCOPE, ɵprovideZonelessChangeDetectionInternal as provideZonelessChangeDetectionInternal, } from '@angular/core';
-import { SymbioteRendererFactory } from '../renderer';
-import { ColorSchemeService, WindowDimensionsService } from '../services';
-// The two FFI-edge casts of this adapter, both confined here to bootstrap. Angular's core
-// types model a browser: the injector parent is a non-null EnvironmentInjector, the host is
-// a DOM Element. Our root has neither shape — a null parent IS a root injector, and the host
-// is a SymbioteSurface (or, for a wrapped AppRegistry root, a plain engine node) the
-// SymbioteRenderer (not the DOM) consumes. These are the sanctioned I/O-edge casts where our
-// objects cross into Angular's web-typed API; revisit if Angular ever exposes a cast-free
-// host. Nothing else in the adapter casts.
-function rootInjectorParent() {
-    return null;
-}
-function asAngularHost(hostNode) {
-    // Angular's locateHostElement reads hostElement.tagName even when a concrete hostElement
-    // is supplied. The host container is given Angular the tiny DOM-shaped field it probes
-    // without changing the renderer target.
-    Object.defineProperty(hostNode, 'tagName', {
-        configurable: true,
-        value: 'symbiote-root',
-    });
-    return hostNode;
-}
-// A bare `symbiote-view` node, created directly through the engine (bypassing Angular's own
-// createElement, which only resolves KNOWN symbiote primitives, never an arbitrary component's
-// selector — see SymbioteRenderer.createElement). Used as the AppRegistry root's host when a
-// wrapperComponentProvider is set: Angular has no hostElement-less bootstrap for our renderer
-// (it would try `renderer.createElement(rootComponent.selector)`, which throws for anything
-// that isn't one of our primitives), so the root needs an explicit host too, one we then hand
-// to the wrapper as projectable content.
-function createDetachedViewHost() {
-    const descriptor = descriptorFor('View');
-    return toPublicInstance(createEngineElement(descriptor.component, descriptor.isText));
-}
-function applyInputs(cmpRef, initialProps) {
-    if (initialProps === undefined)
-        return;
-    for (const [key, value] of Object.entries(initialProps)) {
-        cmpRef.setInput(key, value);
-    }
-}
-// One Angular app per surface, so a surface can be torn down (unmount) or cleanly
-// re-mounted on the same rootTag: the bridgeless host stops and restarts a surface on Fast
-// Refresh and on lifecycle/focus changes, reusing the rootTag.
-const apps = new Map();
-function teardown(rootTag) {
-    const app = apps.get(rootTag);
-    if (app === undefined)
-        return;
-    app.rootRef?.destroy();
-    app.cmpRef.destroy();
-    app.injector.destroy();
-    apps.delete(rootTag);
-    disposeRoot(rootTag);
-}
-export function mount(rootTag, rootComponent, options) {
-    // A re-mount on a live rootTag starts clean; otherwise the stale app double-drives the surface.
-    teardown(rootTag);
-    const surface = createSurface(rootTag);
-    const injector = createEnvironmentInjector([
-        {
-            provide: RendererFactory2,
-            useValue: new SymbioteRendererFactory(surface),
-        },
-        { provide: DOCUMENT, useValue: { head: surface, body: surface } },
-        // createEnvironmentInjector with a null parent gives this injector scope
-        // {'environment'} only (see EnvironmentNgModuleRefAdapter), so providedIn:'root'
-        // tokens — ApplicationRef included — never resolve on their own (R3Injector.get
-        // walks up looking for an injector whose `scopes` contains 'root', and a null
-        // parent means that search always dead-ends in NullInjector). platform-browser's
-        // BROWSER_MODULE_PROVIDERS solves this the same way for real DOM apps: it hands
-        // { provide: INJECTOR_SCOPE, useValue: 'root' } to its OWN app-level providers, and
-        // R3Injector's constructor reads that provider and self-tags this.scopes with
-        // 'root'. We do the same here — no PlatformRef, no DOM, just this one provider.
-        { provide: INJECTOR_SCOPE, useValue: 'root' },
-        // Supplies the real ChangeDetectionSchedulerImpl (microtask-batched, self-scheduling
-        // via ApplicationRef.afterTick) + NoopNgZone + ZONELESS_ENABLED: true — the exact
-        // bundle internalCreateApplication() uses. With ApplicationRef reachable (see above),
-        // there is no more reason for a hand-rolled scheduler: it replaces our old
-        // unconditional `rootView.detectChanges(); cmpView.detectChanges()` (which force-ran
-        // BOTH root views on every tick regardless of cause) with Angular's own tick(), which
-        // only enters an attached view when something actually marked it (RefreshView / Dirty
-        // consumer / HasChildViewsToRefresh). NOTE: this does NOT stop the root's own template
-        // from re-running on a plain press or `ChangeDetectorRef.markForCheck()` anywhere in
-        // the tree — `markViewDirty` (which both native (event) bindings and `markForCheck()`
-        // go through, see SymbioteHostPropsDirective) unconditionally sets RefreshView on
-        // EVERY ancestor up to the root; that is fundamental, unavoidable Angular zoneless
-        // behavior, true in every Angular app, not something this swap changes. What DOES
-        // still protect a sibling branch from an unrelated press is a genuine child
-        // `@Component` boundary — SignalView-compiled children are skip-eligible regardless of
-        // this scheduler.
-        ...provideZonelessChangeDetectionInternal(),
-        // Angular's own INTERNAL_APPLICATION_ERROR_HANDLER (core.mjs) reports a tick()
-        // exception by calling `injector.get(ErrorHandler)` — a normal `bootstrapApplication`
-        // registers this token by default (platform-browser's BROWSER_MODULE_PROVIDERS), but
-        // our from-scratch environment injector never did, so that lookup itself threw
-        // NG0201 and REPLACED whatever the real error was with an unrelated "No provider
-        // found for ErrorHandler" — the real exception never got logged, and the NG0201 itself
-        // propagated out of a bare Timeout callback uncaught (nothing above it in the stack to
-        // catch it), i.e. any async tick() exception, anywhere in the app, crashed hard instead
-        // of being reported. Providing the default `ErrorHandler` (same one bootstrapApplication
-        // ships) restores the intended behavior: `console.error('ERROR', e)` and keep running.
-        { provide: ErrorHandler, useClass: ErrorHandler },
-        ColorSchemeService,
-        WindowDimensionsService,
-    ], rootInjectorParent());
-    // hostElement = the surface: the component's template content commits straight into the
-    // surface with no wrapper view, the engine wrapping surface.children in its synthetic flex
-    // root — the Angular equivalent of Vue's `app.mount(surface)`.
-    let cmpRef;
-    let rootRef;
-    if (options?.wrapperComponent === undefined) {
-        cmpRef = createComponent(rootComponent, {
-            environmentInjector: injector,
-            hostElement: asAngularHost(surface),
-        });
-        applyInputs(cmpRef, options?.initialProps);
-    }
-    else {
-        // The root gets its own host node from the renderer (createComponent without a
-        // hostElement) but is not attached to the surface directly; it is handed to the
-        // wrapper as projectable content instead, so only the wrapper needs a real host.
-        const rootHost = asAngularHost(createDetachedViewHost());
-        rootRef = createComponent(rootComponent, {
-            environmentInjector: injector,
-            hostElement: rootHost,
-        });
-        applyInputs(rootRef, options.initialProps);
-        cmpRef = createComponent(options.wrapperComponent, {
-            environmentInjector: injector,
-            hostElement: asAngularHost(surface),
-            projectableNodes: [[rootHost]],
-        });
-    }
-    // Attach both root views to ApplicationRef so its own tick() (via the real
-    // ChangeDetectionSchedulerImpl provided above) drives them from here on — no manual
-    // ChangeDetectorRef juggling needed. markForCheck anywhere in the tree now notifies
-    // the real scheduler, which batches a microtask and calls appRef.tick() itself.
-    const appRef = injector.get(ApplicationRef);
-    appRef.attachView(cmpRef.hostView);
-    if (rootRef !== undefined) {
-        appRef.attachView(rootRef.hostView);
-    }
-    dlog(`angular mount root=${rootTag}`);
-    appRef.tick(); // first paint
-    surface.requestCommit();
-    apps.set(rootTag, { cmpRef, rootRef, injector });
-    return surface;
-}
-// Tear down a surface by rootTag: the public pair of `mount`, and the JS half of the
-// bridgeless `RN$stopSurface` contract (see installStopSurfaceGlobal).
-export function unmount(rootTag) {
-    dlog(`angular unmount root=${rootTag}`);
-    teardown(rootTag);
-}
-function installStopSurfaceGlobal() {
-    globalThis.RN$stopSurface = (surfaceId) => {
-        unmount(surfaceId);
-    };
-    dlog('installed global.RN$stopSurface');
-}
-installStopSurfaceGlobal();

package/build/renderer/index.d.ts

@@ -1,38 +0,0 @@
-import { SymbioteSurface, type ISymbioteNode } from '@symbiote-native/engine';
-import type { Renderer2, RendererFactory2, RendererType2 } from '@angular/core';
-type IHostNode = ISymbioteNode;
-type IHostElement = ISymbioteNode | SymbioteSurface;
-export declare function registerComposedComponent(selector: string): void;
-export declare class SymbioteRenderer implements Renderer2 {
-    private readonly surface;
-    readonly data: Record<string, unknown>;
-    destroyNode: ((node: ISymbioteNode) => void) | null;
-    constructor(surface: SymbioteSurface);
-    destroy(): void;
-    createElement(name: string): IHostNode;
-    createComment(): IHostNode;
-    createText(value: string): IHostNode;
-    appendChild(parent: IHostElement | null, newChild: IHostNode): void;
-    insertBefore(parent: IHostElement | null, newChild: IHostNode, refChild: IHostNode | null): void;
-    removeChild(_parent: IHostElement | null, oldChild: IHostNode): void;
-    parentNode(node: IHostNode): IHostElement | null;
-    nextSibling(node: IHostNode): IHostNode | null;
-    selectRootElement(selectorOrNode: string | IHostElement): IHostElement;
-    setAttribute(el: IHostElement, name: string, value: string): void;
-    removeAttribute(el: IHostElement, name: string): void;
-    private readonly classTokens;
-    addClass(el: IHostElement, name: string): void;
-    removeClass(el: IHostElement, name: string): void;
-    setStyle(el: IHostElement, style: string, value: unknown): void;
-    removeStyle(el: IHostElement, style: string): void;
-    setProperty(el: IHostElement, name: string, value: unknown): void;
-    setValue(node: IHostNode, value: string): void;
-    listen(target: unknown, eventName: string, callback: (event: unknown) => boolean | void): () => void;
-}
-export declare class SymbioteRendererFactory implements RendererFactory2 {
-    private readonly surface;
-    private renderer;
-    constructor(surface: SymbioteSurface);
-    createRenderer(_hostElement: unknown, _type: RendererType2 | null): Renderer2;
-}
-export {};