@symbiote-native/blur 0.0.0-stage → 0.1.0

package/build/angular/blur-view.js

@@ -0,0 +1,138 @@
+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 {};

package/build/core/blur.js

@@ -0,0 +1,104 @@
+// Ядро `BlurView` и `BlurTargetView`, порт `BlurView.tsx` из expo-blur
+import { Platform, requireNativeViewManager } from 'expo-modules-core';
+import { el } from '@symbiote-native/components';
+import { defineExpoNativeViews, getNativeTag, isSymbioteNode, whenCommitted, } from '@symbiote-native/engine';
+export const BLUR_MODULE_NAME = 'ExpoBlur';
+const BLUR_VIEW_NAME = 'ExpoBlurView';
+const BLUR_TARGET_VIEW_NAME = 'ExpoBlurTargetView';
+const BLUR_METHODS = [
+    'none',
+    'dimezisBlurView',
+    'dimezisBlurViewSdk31Plus',
+];
+const DEFAULT_BLUR_METHOD = BLUR_METHODS[0];
+// Эти ключи разбираются здесь, остальное уходит на View как есть
+const BLUR_KEYS = new Set([
+    'tint',
+    'intensity',
+    'blurReductionFactor',
+    'experimentalBlurMethod',
+    'blurMethod',
+]);
+const ABSOLUTE_FILL = {
+    position: 'absolute',
+    left: 0,
+    right: 0,
+    top: 0,
+    bottom: 0,
+};
+const CONTAINER_STYLE = { backgroundColor: 'transparent' };
+const DEPRECATED_METHOD_WARNING = 'The `experimentalBlurMethod` prop has been depracated. Please use the `blurMethod` prop instead.';
+// Регистрация идёт при рендере: побочный эффект барреля теряется в release
+const views = defineExpoNativeViews(requireNativeViewManager, BLUR_MODULE_NAME, {
+    blur: BLUR_VIEW_NAME,
+    target: BLUR_TARGET_VIEW_NAME,
+});
+export const blurViewName = views.blur.name;
+export const blurTargetViewName = views.target.name;
+export const ensureBlurRegistered = views.blur.ensureRegistered;
+export const ensureBlurTargetRegistered = views.target.ensureRegistered;
+function isBlurMethod(value) {
+    return BLUR_METHODS.some(method => method === value);
+}
+function blurMethodOf(props) {
+    const provided = Reflect.get(props, 'blurMethod');
+    const deprecated = Reflect.get(props, 'experimentalBlurMethod');
+    if (isBlurMethod(provided))
+        return provided;
+    return isBlurMethod(deprecated) ? deprecated : DEFAULT_BLUR_METHOD;
+}
+/** Предупреждения из `componentDidMount` upstream, зовутся один раз при монтировании */
+export function warnBlurProps(props, hasBlurTarget) {
+    const method = blurMethodOf(props);
+    const isAndroidTarget = Platform.select({ android: true, default: false });
+    if (isAndroidTarget && method !== DEFAULT_BLUR_METHOD && !hasBlurTarget) {
+        console.warn(`You have selected the "${method}" blur method, but the \`blurTarget\` prop has not been configured. The blur view will fallback to "none" blur method to avoid errors. You can learn more about the new BlurView API at: https://docs.expo.dev/versions/latest/sdk/blur-view/`);
+    }
+    if (Reflect.get(props, 'experimentalBlurMethod') != null) {
+        console.warn(DEPRECATED_METHOD_WARNING);
+    }
+}
+/**
+ * Отдаёт нативный тег цели размытия после её коммита, у не-узла отдаёт `undefined`
+ * Адаптер сам приводит свой ref к host-узлу, возвращённая функция отменяет ожидание
+ */
+export function watchBlurTarget(target, onId) {
+    if (!isSymbioteNode(target)) {
+        onId(undefined);
+        return () => { };
+    }
+    return whenCommitted(target, () => onId(getNativeTag(target)));
+}
+// `object`, а не тип пропсов: Vue и Angular отдают нетипизированный набор атрибутов
+export function renderBlurView(props, blurTargetId) {
+    const hostProps = Object.fromEntries(Object.entries(props).filter(([key]) => !BLUR_KEYS.has(key)));
+    const style = [CONTAINER_STYLE, Reflect.get(props, 'style')];
+    if (!ensureBlurRegistered()) {
+        console.warn('BlurView is not available on this platform');
+        return el('view', { ...hostProps, style });
+    }
+    const tint = Reflect.get(props, 'tint');
+    const intensity = Reflect.get(props, 'intensity');
+    const reduction = Reflect.get(props, 'blurReductionFactor');
+    const native = el(blurViewName(), {
+        ...(blurTargetId === undefined ? {} : { blurTargetId }),
+        tint: tint ?? 'default',
+        intensity: intensity ?? 50,
+        blurReductionFactor: reduction ?? 4,
+        blurMethod: blurMethodOf(props),
+        style: ABSOLUTE_FILL,
+    });
+    return el('view', { ...hostProps, style }, [native]);
+}
+// Нативная цель размытия есть только на Android, на iOS это обычный View
+export function renderBlurTargetView(props) {
+    const hostProps = { ...props };
+    if (!Platform.select({ android: true, default: false })) {
+        return el('view', hostProps);
+    }
+    if (!ensureBlurTargetRegistered()) {
+        console.warn('BlurTargetView is not available on this platform');
+        return el('view', hostProps);
+    }
+    return el(blurTargetViewName(), hostProps);
+}

package/build/core/index.d.ts

@@ -0,0 +1 @@
+export { BLUR_MODULE_NAME, blurTargetViewName, blurViewName, ensureBlurRegistered, ensureBlurTargetRegistered, renderBlurTargetView, renderBlurView, warnBlurProps, watchBlurTarget, type IBlurMethod, type IBlurTargetViewProps, type IBlurTint, type IBlurViewProps, } from './blur';

package/build/core/index.js

@@ -0,0 +1 @@
+export { BLUR_MODULE_NAME, blurTargetViewName, blurViewName, ensureBlurRegistered, ensureBlurTargetRegistered, renderBlurTargetView, renderBlurView, warnBlurProps, watchBlurTarget, } from './blur.js';

package/build/react/blur.d.ts

@@ -0,0 +1,18 @@
+import type { ReactElement, ReactNode, RefObject } from 'react';
+import type { IHostInstance, IViewProps } from '@symbiote-native/react';
+import type { IBlurTargetViewProps, IBlurViewProps } from '../core';
+export type IBlurViewReactProps = IBlurViewProps & Omit<IViewProps, keyof IBlurViewProps | 'children'> & {
+    /** Ref на `BlurTargetView`, его содержимое это фон для размытия */
+    blurTarget?: RefObject<IHostInstance | null>;
+    children?: ReactNode;
+    className?: string;
+};
+export type IBlurTargetViewReactProps = IBlurTargetViewProps & Omit<IViewProps, keyof IBlurTargetViewProps | 'children' | 'ref'> & {
+    ref?: RefObject<IHostInstance | null>;
+    children?: ReactNode;
+    className?: string;
+};
+/** React twin of `expo-blur`'s `BlurView`, children paint over the blur */
+export declare function BlurView(props: IBlurViewReactProps): ReactElement;
+/** React twin of `expo-blur`'s `BlurTargetView`, native on Android and a plain View on iOS */
+export declare function BlurTargetView(props: IBlurTargetViewReactProps): ReactElement;

package/build/react/blur.js

@@ -0,0 +1,18 @@
+import { createElement, useEffect, useLayoutEffect, useState } from 'react';
+import { descriptorToReactWithChildren } from '@symbiote-native/react';
+import { renderBlurTargetView, renderBlurView, warnBlurProps, watchBlurTarget, } from '../core/index.js';
+/** React twin of `expo-blur`'s `BlurView`, children paint over the blur */
+export function BlurView(props) {
+    const { blurTarget, children, ...rest } = props;
+    const [blurTargetId, setBlurTargetId] = useState();
+    // Без списка зависимостей, как `componentDidUpdate` upstream: ref цели ставится в коммите
+    useLayoutEffect(() => watchBlurTarget(blurTarget?.current, setBlurTargetId));
+    useEffect(() => warnBlurProps(rest, blurTarget !== undefined), []);
+    return descriptorToReactWithChildren(renderBlurView(rest, blurTargetId), children);
+}
+/** React twin of `expo-blur`'s `BlurTargetView`, native on Android and a plain View on iOS */
+export function BlurTargetView(props) {
+    const { children, ...rest } = props;
+    const descriptor = renderBlurTargetView(rest);
+    return createElement(descriptor.type, descriptor.props, children);
+}

package/build/react/index.d.ts

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

package/build/react/index.js

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

package/build/solid/blur.d.ts

@@ -0,0 +1,19 @@
+import type { JSX } from 'solid-js';
+import { descriptorToSolid } from '@symbiote-native/solid';
+import type { IHostInstance, IViewProps } from '@symbiote-native/solid';
+import type { IClassNameValue } from '@symbiote-native/engine';
+import type { IBlurTargetViewProps, IBlurViewProps } from '../core';
+export type IBlurViewSolidProps = IBlurViewProps & Omit<IViewProps, keyof IBlurViewProps | 'children' | 'ref'> & {
+    /** Host-узел `BlurTargetView`, его содержимое это фон для размытия */
+    blurTarget?: IHostInstance;
+    children?: JSX.Element;
+    class?: IClassNameValue;
+};
+export type IBlurTargetViewSolidProps = IBlurTargetViewProps & Omit<IViewProps, keyof IBlurTargetViewProps | 'children'> & {
+    children?: JSX.Element;
+    class?: IClassNameValue;
+};
+/** Solid twin of `expo-blur`'s `BlurView`, children paint over the blur */
+export declare function BlurView(props: IBlurViewSolidProps): ReturnType<typeof descriptorToSolid>;
+/** Solid twin of `expo-blur`'s `BlurTargetView`, native on Android and a plain View on iOS */
+export declare const BlurTargetView: (props: IBlurTargetViewSolidProps) => import("@symbiote-native/engine").ISymbioteNode;

package/build/solid/blur.js

@@ -0,0 +1,17 @@
+import { createEffect, createSignal, onCleanup, onMount, splitProps, } from 'solid-js';
+import { defineDescriptorComponent, descriptorToSolid, } from '@symbiote-native/solid';
+import { renderBlurTargetView, renderBlurView, warnBlurProps, watchBlurTarget, } from '../core/index.js';
+/** Solid twin of `expo-blur`'s `BlurView`, children paint over the blur */
+export function BlurView(props) {
+    const [local, rest] = splitProps(props, ['children', 'blurTarget']);
+    const [blurTargetId, setBlurTargetId] = createSignal();
+    // Цель приходит сигналом после коммита, поэтому следим за ней, а не читаем один раз
+    createEffect(() => {
+        const cancel = watchBlurTarget(local.blurTarget, setBlurTargetId);
+        onCleanup(cancel);
+    });
+    onMount(() => warnBlurProps({ ...rest }, local.blurTarget !== undefined));
+    return descriptorToSolid(() => renderBlurView({ ...rest }, blurTargetId()), () => local.children);
+}
+/** Solid twin of `expo-blur`'s `BlurTargetView`, native on Android and a plain View on iOS */
+export const BlurTargetView = defineDescriptorComponent(renderBlurTargetView);

package/build/solid/index.d.ts

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

package/build/solid/index.js

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

package/build/svelte/blur-props.d.ts

@@ -0,0 +1,13 @@
+import type { Snippet } from 'svelte';
+import type { IViewProps } from '@symbiote-native/svelte';
+import type { IBlurTargetViewProps, IBlurViewProps } from '../core';
+export type IBlurViewSvelteProps = IBlurViewProps & Omit<IViewProps, keyof IBlurViewProps | 'children'> & {
+    /** Значение `bind:ref` от `BlurTargetView`, его содержимое это фон для размытия */
+    blurTarget?: unknown;
+    children?: Snippet;
+};
+export type IBlurTargetViewSvelteProps = IBlurTargetViewProps & Omit<IViewProps, keyof IBlurTargetViewProps | 'children'> & {
+    /** Host-ref, отдаётся через `bind:ref` и передаётся в `blurTarget` у `BlurView` */
+    ref?: unknown;
+    children?: Snippet;
+};

package/build/svelte/blur-props.js

@@ -0,0 +1 @@
+export {};

package/build/svelte/blur-target-view.svelte

@@ -0,0 +1,14 @@
+<script lang="ts">
+  import DescriptorHost from '@symbiote-native/svelte/descriptor-host';
+  import { renderBlurTargetView } from '../core';
+  import type { IBlurTargetViewSvelteProps } from './blur-props';
+
+  let {
+    children,
+    ref = $bindable(),
+    ...rest
+  }: IBlurTargetViewSvelteProps = $props();
+  const descriptor = $derived(renderBlurTargetView({ ...rest }));
+</script>
+
+<DescriptorHost {descriptor} bind:ref {children} />

package/build/svelte/blur-target-view.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { IBlurTargetViewSvelteProps } from './blur-props';
+declare const BlurTargetView: import("svelte").Component<IBlurTargetViewSvelteProps, {}, "ref">;
+type BlurTargetView = ReturnType<typeof BlurTargetView>;
+export default BlurTargetView;

package/build/svelte/blur-view.svelte

@@ -0,0 +1,21 @@
+<script lang="ts">
+  import DescriptorHost from '@symbiote-native/svelte/descriptor-host';
+  import { hostInstance } from '@symbiote-native/svelte/native-view-bridge';
+  import { renderBlurView, warnBlurProps, watchBlurTarget } from '../core';
+  import type { IBlurViewSvelteProps } from './blur-props';
+
+  const { children, blurTarget, ...rest }: IBlurViewSvelteProps = $props();
+  let blurTargetId = $state<number | undefined>();
+
+  // Цель приходит после монтирования и мутирует, поэтому эффект следит за ней
+  $effect(() =>
+    watchBlurTarget(hostInstance(blurTarget), id => {
+      blurTargetId = id;
+    }),
+  );
+  $effect(() => warnBlurProps({ ...rest }, blurTarget !== undefined));
+
+  const descriptor = $derived(renderBlurView({ ...rest }, blurTargetId));
+</script>
+
+<DescriptorHost {descriptor} {children} />

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

@@ -0,0 +1,4 @@
+import type { IBlurViewSvelteProps } from './blur-props';
+declare const BlurView: import("svelte").Component<IBlurViewSvelteProps, {}, "">;
+type BlurView = ReturnType<typeof BlurView>;
+export default BlurView;

package/build/svelte/index.d.ts

@@ -0,0 +1,4 @@
+export { default as BlurTargetView } from './blur-target-view.svelte';
+export { default as BlurView } from './blur-view.svelte';
+export type { IBlurTargetViewSvelteProps as IBlurTargetViewProps, IBlurViewSvelteProps as IBlurViewProps, } from './blur-props';
+export { BLUR_MODULE_NAME, blurTargetViewName, blurViewName, type IBlurMethod, type IBlurTint, } from '../core';

package/build/svelte/index.js

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

package/build/vue/blur.d.ts

@@ -0,0 +1,12 @@
+import { type VNode } from '@vue/runtime-core';
+import type { IViewProps } from '@symbiote-native/vue';
+import type { IBlurTargetViewProps, IBlurViewProps } from '../core';
+export type IBlurViewVueProps = IBlurViewProps & Omit<IViewProps, keyof IBlurViewProps> & {
+    /** Template ref на `BlurTargetView`, его содержимое это фон для размытия */
+    blurTarget?: unknown;
+};
+export type IBlurTargetViewVueProps = IBlurTargetViewProps & Omit<IViewProps, keyof IBlurTargetViewProps>;
+/** Vue twin of `expo-blur`'s `BlurView`, the default slot paints over the blur */
+export declare const BlurView: import("vue").DefineComponent<{}, () => VNode, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/** Vue twin of `expo-blur`'s `BlurTargetView`, native on Android and a plain View on iOS */
+export declare const BlurTargetView: import("vue").DefineComponent<{}, () => VNode, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/build/vue/blur.js

@@ -0,0 +1,50 @@
+import { defineComponent, h, isRef, onBeforeUnmount, onMounted, onUpdated, ref, toRaw, } from '@vue/runtime-core';
+import { descriptorToVue, normalizeVueAttrs } from '@symbiote-native/vue';
+import { renderBlurTargetView, renderBlurView, warnBlurProps, watchBlurTarget, } from '../core/index.js';
+// Template ref на компонент отдаёт его публичный экземпляр, корневой host-узел лежит в `$el`
+function hostOf(target) {
+    const value = isRef(target) ? target.value : target;
+    const host = value !== null && typeof value === 'object' && '$el' in value
+        ? value.$el
+        : value;
+    return toRaw(host);
+}
+/** Vue twin of `expo-blur`'s `BlurView`, the default slot paints over the blur */
+export const BlurView = defineComponent({
+    name: 'BlurView',
+    // Все атрибуты это пропсы нативного view, на обёртку ничего не должно просочиться
+    inheritAttrs: false,
+    setup(_props, { attrs, slots }) {
+        const blurTargetId = ref();
+        let cancelWatch = () => { };
+        const syncTarget = () => {
+            cancelWatch();
+            cancelWatch = watchBlurTarget(hostOf(attrs.blurTarget), id => {
+                blurTargetId.value = id;
+            });
+        };
+        // Ref цели ставится при патче, поэтому читаем его после монтирования и каждого обновления
+        onMounted(() => {
+            syncTarget();
+            warnBlurProps(normalizeVueAttrs(attrs), attrs.blurTarget !== undefined);
+        });
+        onUpdated(syncTarget);
+        onBeforeUnmount(() => cancelWatch());
+        return () => {
+            const { blurTarget: _blurTarget, ...rest } = normalizeVueAttrs(attrs);
+            const descriptor = renderBlurView(rest, blurTargetId.value);
+            return descriptorToVue(descriptor, slots.default?.() ?? []);
+        };
+    },
+});
+/** Vue twin of `expo-blur`'s `BlurTargetView`, native on Android and a plain View on iOS */
+export const BlurTargetView = defineComponent({
+    name: 'BlurTargetView',
+    inheritAttrs: false,
+    setup(_props, { attrs, slots }) {
+        return () => {
+            const descriptor = renderBlurTargetView(normalizeVueAttrs(attrs));
+            return h(descriptor.type, descriptor.props, slots.default?.() ?? []);
+        };
+    },
+});

package/build/vue/index.d.ts

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

package/build/vue/index.js

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

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

@@ -0,0 +1,10 @@
+import { BlurTargetViewBase } from './shared';
+import * as i0 from "@angular/core";
+/** 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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BlurTargetView, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BlurTargetView, "BlurTargetView", never, {}, {}, never, ["*"], true, never>;
+}

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

@@ -0,0 +1,46 @@
+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';
+import { BlurTargetViewBase } from './shared';
+import * as i0 from "@angular/core";
+const TEMPLATE_TAG = 'ViewManagerAdapter_ExpoBlur_ExpoBlurTargetView';
+/** Angular twin of `expo-blur`'s `BlurTargetView`, the native target view on Android */
+export class BlurTargetView extends BlurTargetViewBase {
+    hostRef;
+    constructor() {
+        super();
+        warnIfViewNameIsDynamic(TEMPLATE_TAG, BLUR_MODULE_NAME, 'ExpoBlurTargetView');
+    }
+    get nativeElement() {
+        return this.hostRef.nativeElement;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: BlurTargetView, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "22.0.8", type: BlurTargetView, isStandalone: true, selector: "BlurTargetView", viewQueries: [{ propertyName: "hostRef", first: true, predicate: ["host"], descendants: true, read: ElementRef, static: true }], usesInheritance: true, ngImport: i0, template: `<ViewManagerAdapter_ExpoBlur_ExpoBlurTargetView
+    #host
+    [symbioteHostProps]="hostProps"
+  >
+    <ng-content />
+  </ViewManagerAdapter_ExpoBlur_ExpoBlurTargetView>`, isInline: true, dependencies: [{ kind: "directive", type: SymbioteHostPropsDirective, selector: "[symbioteHostProps]", inputs: ["symbioteHostProps"], exportAs: ["symbioteHost"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: BlurTargetView, decorators: [{
+            type: Component,
+            args: [{
+                    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>`,
+                }]
+        }], ctorParameters: () => [], propDecorators: { hostRef: [{
+                type: ViewChild,
+                args: ['host', { read: ElementRef, static: true }]
+            }] } });
+//# sourceMappingURL=index.android.js.map