@symbiote-native/blur 0.0.0-stage → 0.1.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,218 @@
-# 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.
+
+Built the same way as [`@symbiote-native/clipboard`](../clipboard)'s `ClipboardPasteButton`, an
+`expo-modules-core` native view reached through `requireNativeViewManager` (see the
+`symbiote-expo-native-module` project skill: why `expo-modules-core` is depended on directly and never
+the `expo` meta-package, why the upstream JS is hand-ported into `core/`, and how autolinking finds the
+native module). One render function in `core/` returns a descriptor and every adapter only turns it into
+its own element.
+
+## Install
+
+**New app:**
+
+```bash
+npx @symbiote-native/cli new my-app --blur
+```
+
+**Existing SymbioteNative app:**
+
+```bash
+npx @symbiote-native/cli add --blur
+```
+
+Either way: installs `@symbiote-native/blur` and wires the native autolinking automatically,
+see [`@symbiote-native/cli`](../cli).
+
+<details>
+<summary>Manual install (no CLI - installing and wiring native autolinking by hand)</summary>
+
+```bash
+npm install @symbiote-native/blur
+```
+
+Depends on `expo-blur` and `expo-modules-core` directly (regular dependencies, pinned to exact
+versions, since this package's `core/` is hand-ported against one specific native API shape).
+Never install `expo-blur` yourself, and never add the `expo` package to this project: it bundles
+its own Metro/Babel pipeline that conflicts with this project's own.
+
+### Required one-time step: native autolinking wiring
+
+`expo-blur`'s native code is discovered by `expo-modules-autolinking`, not by RN's own
+`react-native.config.cjs` mechanism. Wire it into the native host app **once**, it covers this package
+and every other `expo-modules-core` package with zero further changes. The steps and the
+mechanics behind them are in the `symbiote-expo-native-module` skill and in
+[`@symbiote-native/network`](../network)'s README; the reference app is `examples/expo-react`.
+
+</details>
+
+## Shape
+
+```
+src/core/                blur.ts - props, the blurMethod warning, watchBlurTarget, renderBlurView
+                         (a View carrying style over an absolute-fill native blur, both platforms) and
+                         renderBlurTargetView (native on Android, a plain View on iOS).
+src/react/               @symbiote-native/blur/react   - BlurView, BlurTargetView
+src/vue/                 @symbiote-native/blur/vue     - BlurView, BlurTargetView
+src/svelte/              @symbiote-native/blur/svelte  - BlurView, BlurTargetView (.svelte)
+src/solid/               @symbiote-native/blur/solid   - BlurView, BlurTargetView
+src/angular/             @symbiote-native/blur/angular - BlurView, BlurTargetView
+```
+
+`blurTarget` is each adapter's own reference to a `BlurTargetView`. The package resolves it to a node
+and waits for the commit (`watchBlurTarget`) before telling native, so a Vue or Svelte render order cannot
+hand native a tag that does not exist yet.
+
+## Use it
+
+### React
+
+```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>;
+```
+
+### Vue
+
+```vue
+<script setup lang="ts">
+import { ref } from '@vue/runtime-core';
+import { BlurTargetView, BlurView } from '@symbiote-native/blur/vue';
+
+const target = ref(null);
+</script>
+
+<template>
+  <BlurTargetView ref="target"><image :source="photo" /></BlurTargetView>
+  <BlurView :blur-target="target" blur-method="dimezisBlurView" tint="light" :intensity="60">
+    <text>Over the blur</text>
+  </BlurView>
+</template>
+```
+
+### Angular
+
+```ts
+import { BlurTargetView, BlurView } from '@symbiote-native/blur/angular';
+
+@Component({
+  imports: [BlurTargetView, BlurView],
+  template: `
+    <BlurTargetView #target><image [source]="photo" /></BlurTargetView>
+    <BlurView [blurTarget]="target" blurMethod="dimezisBlurView" tint="light" [intensity]="60">
+      <text>Over the blur</text>
+    </BlurView>
+  `,
+})
+export class Card {}
+```
+
+### Svelte
+
+```svelte
+<script lang="ts">
+  import { BlurTargetView, BlurView } from '@symbiote-native/blur/svelte';
+
+  let target = $state<unknown>();
+</script>
+
+<BlurTargetView bind:ref={target}><image source={photo} /></BlurTargetView>
+<BlurView blurTarget={target} blurMethod="dimezisBlurView" tint="light" intensity={60}>
+  <text>Over the blur</text>
+</BlurView>
+```
+
+### Solid
+
+```tsx
+import { createSignal } from 'solid-js';
+import { BlurTargetView, BlurView } from '@symbiote-native/blur/solid';
+
+const [target, setTarget] = createSignal<IHostInstance>();
+
+<BlurTargetView ref={setTarget}><image source={photo} /></BlurTargetView>;
+<BlurView blurTarget={target()} blurMethod="dimezisBlurView" tint="light" intensity={60}>
+  <text>Over the blur</text>
+</BlurView>;
+```
+
+## API
+
+```ts
+<BlurView
+  tint?={'default' | 'light' | 'dark' | 'extraLight' | 'regular' | system materials}
+  intensity?={number}                  // 1..100, default 50
+  blurMethod?={'none' | 'dimezisBlurView' | 'dimezisBlurViewSdk31Plus'}   // Android, default 'none'
+  blurReductionFactor?={number}        // Android, divides the intensity, default 4
+  blurTarget?={BlurTargetView ref}     // Android, needed by the dimezis methods
+  style? testID? nativeID? onLayout? ...View accessibility and responder props
+/>
+<BlurTargetView ref>                   // native on Android, a plain View on iOS
+```
+
+Ported from upstream's `BlurView.tsx` and `BlurTargetView.tsx`.
+
+## Notes
+
+- **Android blurs nothing until you ask for it.** `blurMethod` defaults to `none`, which is only a
+  translucent view. Pick `dimezisBlurView` (or `dimezisBlurViewSdk31Plus`) and pass a `blurTarget`.
+  Without a target the package warns and falls back to `none`.
+- **One `BlurTargetView` can serve many `BlurView`s**, as long as they all sit inside its bounds.
+  That is cheaper than one target per blur.
+- **The blur view must be above what it blurs.** Place it after the content in the tree (or give it
+  a higher `zIndex`), not beside or under it.
+- **Every iOS tint adds a translucent layer.** Each `tint` is a system material that sits over the
+  blur, and iOS exposes no plain blur radius. Android and the fallback can go without a tint.
+- **`blurReductionFactor` is Android only.** It divides the intensity to bring the Android blur
+  closer to iOS.
+- **Without the native view you get a plain `View`.** The package logs
+  `BlurView is not available on this platform` and renders your children without a blur.
+- **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.
+
+## Common questions
+
+- **Nothing is blurred on Android.** `blurMethod` defaults to `none`. Wrap the content in a
+  `BlurTargetView`, pass its ref as `blurTarget` and set `blurMethod="dimezisBlurView"`.
+- **The blur does not follow a scrolling list.** Render the blur view after the content, or give it
+  a higher `zIndex`. Beside or below the list it shows nothing.
+- **Inside a `Modal` on Android.** Put the `Modal` inside the `BlurTargetView` and point the
+  `BlurView` in the `Modal` at that target. Not demoed in the canary apps.
+- **Corners are not rounded.** Put `overflow: 'hidden'` next to the `borderRadius`.
+- **Missing on some iPhones.** Settings > Accessibility > Display & Text Size > Reduce Transparency
+  turns blur off. Render a solid fallback.
+- **No tint.** Not possible on iOS, every system blur style adds a tint layer.
+- **Animating `intensity`.** It is a plain prop, drive it from state, a signal or a rune.
+- **Android build cannot find `BlurView`.** The library comes from JitPack, which React Native's
+  Gradle plugin adds by default. It fails if `react.includeJitpackRepository=false`.
+
+Sources: [Expo docs: BlurView](https://docs.expo.dev/versions/latest/sdk/blur-view/),
+[expo/expo#6613](https://github.com/expo/expo/issues/6613),
+[expo/expo#44165](https://github.com/expo/expo/issues/44165),
+[expo/expo#18615](https://github.com/expo/expo/issues/18615),
+[expo/expo#34737](https://github.com/expo/expo/issues/34737),
+[expo/expo#49240](https://github.com/expo/expo/issues/49240),
+[expo/expo#32781](https://github.com/expo/expo/issues/32781),
+[expo/expo#34141](https://github.com/expo/expo/issues/34141).
+
+## Test it
+
+No device is needed for the logic. The core tests (`src/core/*.test.ts`) replace `expo-modules-core`
+(`requireNativeViewManager`, `Platform`) and assert the descriptor a render function returns. The
+adapter tests (`src/{react,vue,solid,angular}/**/*.test.*`, `vitest`) render the real component over the
+recording Fabric with an injected view config and assert the committed payload, and Svelte's
+`*.smoke.test.ts` compile the `.svelte` files and mount them. Painting itself is verified on a device in
+the six `examples/expo-*` canary apps (`examples/expo-react`, `examples/expo-vue-sfc`,
+`examples/expo-vue-tsx`, `examples/expo-svelte`, `examples/expo-solid`, `examples/expo-angular`), see the
+parent [README](../../README.md).

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,87 @@
+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;
+}