@symbiote-native/blur 0.0.0-stage → 0.0.0

package/LICENSE

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

package/README.md

@@ -1,3 +1,52 @@
-# Temporary Holding Version
+# @symbiote-native/blur
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[`expo-blur`](https://docs.expo.dev/versions/latest/sdk/blur-view/) for **every**
+[SymbioteNative](../../README.md) adapter: React, Vue, Svelte, Solid and Angular. `BlurView` blurs
+what is behind it, `BlurTargetView` marks the content Android blurs.
+
+## Install
+
+```bash
+npx @symbiote-native/cli new my-app --blur   # new app
+npx @symbiote-native/cli add --blur          # existing app
+```
+
+Manual: `npm install @symbiote-native/blur`, then wire `expo-modules-autolinking` once per app.
+Never install `expo-blur` or the `expo` meta-package yourself.
+
+## Usage
+
+```tsx
+import { BlurTargetView, BlurView } from '@symbiote-native/blur/react';
+
+const target = useRef<IHostInstance>(null);
+
+<BlurTargetView ref={target}>
+  <Image source={photo} />
+</BlurTargetView>;
+<BlurView blurTarget={target} blurMethod="dimezisBlurView" tint="light" intensity={60}>
+  <Text>Over the blur</Text>
+</BlurView>;
+```
+
+Same props on every adapter: `tint`, `intensity`, `blurMethod`, `blurReductionFactor` and the View
+surface. `blurTarget` takes each framework's own reference to the `BlurTargetView`:
+
+| Adapter | Target reference                       |
+| ------- | -------------------------------------- |
+| React   | `ref` object on `BlurTargetView`       |
+| Vue     | template ref on `BlurTargetView`       |
+| Svelte  | `bind:ref` on `BlurTargetView`         |
+| Solid   | `ref={setTarget}` signal value         |
+| Angular | template reference variable `#target`  |
+
+## Layout
+
+A transparent `View` holds the style and children, with the native blur filling it behind them.
+`BlurTargetView` is native on Android and a plain `View` on iOS, where blur needs no target.
+
+## Not ported
+
+The web variant (`BlurView.web.tsx`, `getBackgroundColor`) and the Reanimated `getAnimatableRef` hook.
+Angular templates spell the Android target tag statically, so an `__expo_app_identifier__` suffix makes
+it warn instead of render.

package/build/angular/blur-target-view/index.android.d.ts

@@ -0,0 +1,7 @@
+import { BlurTargetViewBase } from './shared';
+/** Angular twin of `expo-blur`'s `BlurTargetView`, the native target view on Android */
+export declare class BlurTargetView extends BlurTargetViewBase {
+    private readonly hostRef;
+    constructor();
+    get nativeElement(): unknown;
+}

package/build/angular/blur-target-view/index.android.js

@@ -0,0 +1,84 @@
+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 { ChangeDetectionStrategy, Component, ElementRef, NO_ERRORS_SCHEMA, ViewChild, } from '@angular/core';
+import { warnIfViewNameIsDynamic } from '@symbiote-native/engine';
+import { SymbioteHostPropsDirective } from '@symbiote-native/angular';
+import { BLUR_MODULE_NAME } from '../../core/index.js';
+import { BlurTargetViewBase } from './shared.js';
+const TEMPLATE_TAG = 'ViewManagerAdapter_ExpoBlur_ExpoBlurTargetView';
+/** Angular twin of `expo-blur`'s `BlurTargetView`, the native target view on Android */
+let BlurTargetView = (() => {
+    let _classDecorators = [Component({
+            selector: 'BlurTargetView',
+            standalone: true,
+            imports: [SymbioteHostPropsDirective],
+            schemas: [NO_ERRORS_SCHEMA],
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            // Имя тега это нативное имя view, его нельзя собрать динамически
+            template: `<ViewManagerAdapter_ExpoBlur_ExpoBlurTargetView #host [symbioteHostProps]="hostProps">
+    <ng-content />
+  </ViewManagerAdapter_ExpoBlur_ExpoBlurTargetView>`,
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = BlurTargetViewBase;
+    let _hostRef_decorators;
+    let _hostRef_initializers = [];
+    let _hostRef_extraInitializers = [];
+    var BlurTargetView = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _hostRef_decorators = [ViewChild('host', { read: ElementRef, static: true })];
+            __esDecorate(null, null, _hostRef_decorators, { kind: "field", name: "hostRef", static: false, private: false, access: { has: obj => "hostRef" in obj, get: obj => obj.hostRef, set: (obj, value) => { obj.hostRef = value; } }, metadata: _metadata }, _hostRef_initializers, _hostRef_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            BlurTargetView = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        hostRef = __runInitializers(this, _hostRef_initializers, void 0);
+        constructor() {
+            super();
+            __runInitializers(this, _hostRef_extraInitializers);
+            warnIfViewNameIsDynamic(TEMPLATE_TAG, BLUR_MODULE_NAME, 'ExpoBlurTargetView');
+        }
+        get nativeElement() {
+            return this.hostRef.nativeElement;
+        }
+    };
+    return BlurTargetView = _classThis;
+})();
+export { BlurTargetView };

package/build/angular/blur-target-view/index.d.ts

@@ -0,0 +1 @@
+export { BlurTargetView } from './index.ios';

package/build/angular/blur-target-view/index.ios.d.ts

@@ -0,0 +1,6 @@
+import { BlurTargetViewBase } from './shared';
+/** Angular twin of `expo-blur`'s `BlurTargetView`, a plain View on iOS */
+export declare class BlurTargetView extends BlurTargetViewBase {
+    private readonly hostRef;
+    get nativeElement(): unknown;
+}

package/build/angular/blur-target-view/index.ios.js

@@ -0,0 +1,76 @@
+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 { ChangeDetectionStrategy, Component, ElementRef, ViewChild, } from '@angular/core';
+import { SymbioteHostPropsDirective, View } from '@symbiote-native/angular';
+import { BlurTargetViewBase } from './shared.js';
+/** Angular twin of `expo-blur`'s `BlurTargetView`, a plain View on iOS */
+let BlurTargetView = (() => {
+    let _classDecorators = [Component({
+            selector: 'BlurTargetView',
+            standalone: true,
+            imports: [SymbioteHostPropsDirective, View],
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            template: `<view #host [symbioteHostProps]="hostProps"><ng-content /></view>`,
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = BlurTargetViewBase;
+    let _hostRef_decorators;
+    let _hostRef_initializers = [];
+    let _hostRef_extraInitializers = [];
+    var BlurTargetView = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _hostRef_decorators = [ViewChild('host', { read: ElementRef, static: true })];
+            __esDecorate(null, null, _hostRef_decorators, { kind: "field", name: "hostRef", static: false, private: false, access: { has: obj => "hostRef" in obj, get: obj => obj.hostRef, set: (obj, value) => { obj.hostRef = value; } }, metadata: _metadata }, _hostRef_initializers, _hostRef_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            BlurTargetView = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        hostRef = __runInitializers(this, _hostRef_initializers, void 0);
+        get nativeElement() {
+            return this.hostRef.nativeElement;
+        }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _hostRef_extraInitializers);
+        }
+    };
+    return BlurTargetView = _classThis;
+})();
+export { BlurTargetView };

package/build/angular/blur-target-view/index.js

@@ -0,0 +1,2 @@
+// Базовая точка для headless и tsc, Metro берёт `index.ios` или `index.android`
+export { BlurTargetView } from './index.ios.js';

package/build/angular/blur-target-view/shared.d.ts

@@ -0,0 +1,9 @@
+import { NativeViewBase } from '@symbiote-native/angular';
+import type { IDescriptor } from '@symbiote-native/components';
+export declare abstract class BlurTargetViewBase extends NativeViewBase {
+    /** Нужен свойству `blurTarget` у `BlurView`, чтобы найти host-узел */
+    abstract readonly nativeElement: unknown;
+    protected readonly propNames: readonly [];
+    protected renderView(props: object): IDescriptor;
+    get hostProps(): Record<string, unknown>;
+}

package/build/angular/blur-target-view/shared.js

@@ -0,0 +1,64 @@
+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, Input } from '@angular/core';
+import { NativeViewBase } from '@symbiote-native/angular';
+import { renderBlurTargetView } from '../../core/index.js';
+// Платформы различаются только тегом в шаблоне, остальное общее
+let BlurTargetViewBase = (() => {
+    let _classDecorators = [Directive()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = NativeViewBase;
+    var BlurTargetViewBase = 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);
+            BlurTargetViewBase = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        propNames = [];
+        renderView(props) {
+            return renderBlurTargetView(props);
+        }
+        get hostProps() {
+            return this.descriptor?.props ?? {};
+        }
+    };
+    return BlurTargetViewBase = _classThis;
+})();
+export { BlurTargetViewBase };

package/build/angular/blur-view.d.ts

@@ -0,0 +1,23 @@
+import { type AfterViewInit, type OnChanges, type OnDestroy, type SimpleChanges } from '@angular/core';
+import { NativeViewBase } from '@symbiote-native/angular';
+import type { IDescriptor } from '@symbiote-native/components';
+import type { IBlurViewProps } from '../core';
+/** Angular twin of `expo-blur`'s `BlurView`, the projected content paints over the blur */
+export declare class BlurView extends NativeViewBase implements AfterViewInit, OnChanges, OnDestroy {
+    tint?: IBlurViewProps['tint'];
+    intensity?: IBlurViewProps['intensity'];
+    blurReductionFactor?: IBlurViewProps['blurReductionFactor'];
+    experimentalBlurMethod?: IBlurViewProps['experimentalBlurMethod'];
+    blurMethod?: IBlurViewProps['blurMethod'];
+    /** Template ref на `BlurTargetView`, его содержимое это фон для размытия */
+    blurTarget?: unknown;
+    protected readonly propNames: readonly ["tint", "intensity", "blurReductionFactor", "experimentalBlurMethod", "blurMethod"];
+    private blurTargetId;
+    private cancelWatch;
+    private isViewReady;
+    protected renderView(props: object): IDescriptor;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    protected disposeView(): void;
+    private watchTarget;
+}

package/build/angular/blur-view.js

@@ -0,0 +1,136 @@
+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 { ChangeDetectionStrategy, Component, Input, } from '@angular/core';
+import { DescriptorHost, NativeViewBase, hostNodeOf, } from '@symbiote-native/angular';
+import { renderBlurView, warnBlurProps, watchBlurTarget } from '../core/index.js';
+/** Angular twin of `expo-blur`'s `BlurView`, the projected content paints over the blur */
+let BlurView = (() => {
+    let _classDecorators = [Component({
+            selector: 'BlurView',
+            standalone: true,
+            imports: [DescriptorHost],
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            template: `@if (descriptor; as node) {
+    <symbiote-descriptor-host [node]="node"><ng-content /></symbiote-descriptor-host>
+  }`,
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = NativeViewBase;
+    let _tint_decorators;
+    let _tint_initializers = [];
+    let _tint_extraInitializers = [];
+    let _intensity_decorators;
+    let _intensity_initializers = [];
+    let _intensity_extraInitializers = [];
+    let _blurReductionFactor_decorators;
+    let _blurReductionFactor_initializers = [];
+    let _blurReductionFactor_extraInitializers = [];
+    let _experimentalBlurMethod_decorators;
+    let _experimentalBlurMethod_initializers = [];
+    let _experimentalBlurMethod_extraInitializers = [];
+    let _blurMethod_decorators;
+    let _blurMethod_initializers = [];
+    let _blurMethod_extraInitializers = [];
+    let _blurTarget_decorators;
+    let _blurTarget_initializers = [];
+    let _blurTarget_extraInitializers = [];
+    var BlurView = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _tint_decorators = [Input()];
+            _intensity_decorators = [Input()];
+            _blurReductionFactor_decorators = [Input()];
+            _experimentalBlurMethod_decorators = [Input()];
+            _blurMethod_decorators = [Input()];
+            _blurTarget_decorators = [Input()];
+            __esDecorate(null, null, _tint_decorators, { kind: "field", name: "tint", static: false, private: false, access: { has: obj => "tint" in obj, get: obj => obj.tint, set: (obj, value) => { obj.tint = value; } }, metadata: _metadata }, _tint_initializers, _tint_extraInitializers);
+            __esDecorate(null, null, _intensity_decorators, { kind: "field", name: "intensity", static: false, private: false, access: { has: obj => "intensity" in obj, get: obj => obj.intensity, set: (obj, value) => { obj.intensity = value; } }, metadata: _metadata }, _intensity_initializers, _intensity_extraInitializers);
+            __esDecorate(null, null, _blurReductionFactor_decorators, { kind: "field", name: "blurReductionFactor", static: false, private: false, access: { has: obj => "blurReductionFactor" in obj, get: obj => obj.blurReductionFactor, set: (obj, value) => { obj.blurReductionFactor = value; } }, metadata: _metadata }, _blurReductionFactor_initializers, _blurReductionFactor_extraInitializers);
+            __esDecorate(null, null, _experimentalBlurMethod_decorators, { kind: "field", name: "experimentalBlurMethod", static: false, private: false, access: { has: obj => "experimentalBlurMethod" in obj, get: obj => obj.experimentalBlurMethod, set: (obj, value) => { obj.experimentalBlurMethod = value; } }, metadata: _metadata }, _experimentalBlurMethod_initializers, _experimentalBlurMethod_extraInitializers);
+            __esDecorate(null, null, _blurMethod_decorators, { kind: "field", name: "blurMethod", static: false, private: false, access: { has: obj => "blurMethod" in obj, get: obj => obj.blurMethod, set: (obj, value) => { obj.blurMethod = value; } }, metadata: _metadata }, _blurMethod_initializers, _blurMethod_extraInitializers);
+            __esDecorate(null, null, _blurTarget_decorators, { kind: "field", name: "blurTarget", static: false, private: false, access: { has: obj => "blurTarget" in obj, get: obj => obj.blurTarget, set: (obj, value) => { obj.blurTarget = value; } }, metadata: _metadata }, _blurTarget_initializers, _blurTarget_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            BlurView = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        tint = __runInitializers(this, _tint_initializers, void 0);
+        intensity = (__runInitializers(this, _tint_extraInitializers), __runInitializers(this, _intensity_initializers, void 0));
+        blurReductionFactor = (__runInitializers(this, _intensity_extraInitializers), __runInitializers(this, _blurReductionFactor_initializers, void 0));
+        experimentalBlurMethod = (__runInitializers(this, _blurReductionFactor_extraInitializers), __runInitializers(this, _experimentalBlurMethod_initializers, void 0));
+        blurMethod = (__runInitializers(this, _experimentalBlurMethod_extraInitializers), __runInitializers(this, _blurMethod_initializers, void 0));
+        /** Template ref на `BlurTargetView`, его содержимое это фон для размытия */
+        blurTarget = (__runInitializers(this, _blurMethod_extraInitializers), __runInitializers(this, _blurTarget_initializers, void 0));
+        propNames = (__runInitializers(this, _blurTarget_extraInitializers), [
+            'tint',
+            'intensity',
+            'blurReductionFactor',
+            'experimentalBlurMethod',
+            'blurMethod',
+        ]);
+        blurTargetId;
+        cancelWatch = () => { };
+        isViewReady = false;
+        renderView(props) {
+            return renderBlurView(props, this.blurTargetId);
+        }
+        // Цель ставится при создании представления соседа, поэтому ждём `ngAfterViewInit`
+        ngAfterViewInit() {
+            this.isViewReady = true;
+            this.watchTarget();
+            warnBlurProps(Object.fromEntries(this.propNames.map(name => [name, Reflect.get(this, name)])), this.blurTarget !== undefined);
+        }
+        ngOnChanges(changes) {
+            super.ngOnChanges(changes);
+            if (this.isViewReady && 'blurTarget' in changes)
+                this.watchTarget();
+        }
+        disposeView() {
+            this.cancelWatch();
+        }
+        watchTarget() {
+            this.cancelWatch();
+            this.cancelWatch = watchBlurTarget(hostNodeOf(this.blurTarget), id => {
+                this.blurTargetId = id;
+                this.changeDetector.markForCheck();
+            });
+        }
+    };
+    return BlurView = _classThis;
+})();
+export { BlurView };

package/build/angular/index.d.ts

@@ -0,0 +1,3 @@
+export { BlurView } from './blur-view';
+export { BlurTargetView } from './blur-target-view';
+export { BLUR_MODULE_NAME, blurTargetViewName, blurViewName, type IBlurMethod, type IBlurTint, type IBlurViewProps, type IBlurTargetViewProps, } from '../core';

package/build/angular/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/blur/angular: компоненты `BlurView` и `BlurTargetView` поверх общего ядра
+export { BlurView } from './blur-view.js';
+export { BlurTargetView } from './blur-target-view';
+export { BLUR_MODULE_NAME, blurTargetViewName, blurViewName, } from '../core/index.js';

package/build/core/blur.d.ts

@@ -0,0 +1,53 @@
+import type { IAccessibilityProps, IAriaProps, IDescriptor, IResponderProps } from '@symbiote-native/components';
+import type { IStyleProp, ISymbioteEvent, IViewStyle } from '@symbiote-native/engine';
+export declare const BLUR_MODULE_NAME = "ExpoBlur";
+declare const BLUR_METHODS: readonly ["none", "dimezisBlurView", "dimezisBlurViewSdk31Plus"];
+/** Метод размытия на Android: `none` это полупрозрачный view, остальные нативный BlurView */
+export type IBlurMethod = (typeof BLUR_METHODS)[number];
+export type IBlurTint = 'light' | 'dark' | 'default' | 'extraLight' | 'regular' | 'prominent' | 'systemUltraThinMaterial' | 'systemThinMaterial' | 'systemMaterial' | 'systemThickMaterial' | 'systemChromeMaterial' | 'systemUltraThinMaterialLight' | 'systemThinMaterialLight' | 'systemMaterialLight' | 'systemThickMaterialLight' | 'systemChromeMaterialLight' | 'systemUltraThinMaterialDark' | 'systemThinMaterialDark' | 'systemMaterialDark' | 'systemThickMaterialDark' | 'systemChromeMaterialDark';
+type IViewSurface = IAccessibilityProps & IAriaProps & IResponderProps & {
+    style?: IStyleProp<IViewStyle>;
+    testID?: string;
+    nativeID?: string;
+    onLayout?: (event: ISymbioteEvent) => void;
+};
+export type IBlurViewProps = IViewSurface & {
+    /** @default 'default' */
+    tint?: IBlurTint;
+    /**
+     * Сила размытия от 1 до 100
+     * @default 50
+     */
+    intensity?: number;
+    /**
+     * Делитель силы размытия на Android
+     * @default 4
+     * @platform android
+     */
+    blurReductionFactor?: number;
+    /**
+     * @deprecated Use `blurMethod` instead
+     * @platform android
+     */
+    experimentalBlurMethod?: IBlurMethod;
+    /**
+     * @default 'none'
+     * @platform android
+     */
+    blurMethod?: IBlurMethod;
+};
+export type IBlurTargetViewProps = IViewSurface;
+export declare const blurViewName: () => string;
+export declare const blurTargetViewName: () => string;
+export declare const ensureBlurRegistered: () => boolean;
+export declare const ensureBlurTargetRegistered: () => boolean;
+/** Предупреждения из `componentDidMount` upstream, зовутся один раз при монтировании */
+export declare function warnBlurProps(props: object, hasBlurTarget: boolean): void;
+/**
+ * Отдаёт нативный тег цели размытия после её коммита, у не-узла отдаёт `undefined`
+ * Адаптер сам приводит свой ref к host-узлу, возвращённая функция отменяет ожидание
+ */
+export declare function watchBlurTarget(target: unknown, onId: (id: number | undefined) => void): () => void;
+export declare function renderBlurView(props: object, blurTargetId: number | null | undefined): IDescriptor;
+export declare function renderBlurTargetView(props: object): IDescriptor;
+export {};