@symbiote-native/linear-gradient 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,43 @@
-# Temporary Holding Version
+# @symbiote-native/linear-gradient
 
-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-linear-gradient`](https://docs.expo.dev/versions/latest/sdk/linear-gradient/) for **every**
+[SymbioteNative](../../README.md) adapter: React, Vue, Svelte, Solid and Angular. A native view that
+paints a multi-color gradient behind its children.
+
+## Install
+
+```bash
+npx @symbiote-native/cli new my-app --linear-gradient   # new app
+npx @symbiote-native/cli add --linear-gradient          # existing app
+```
+
+Manual: `npm install @symbiote-native/linear-gradient`, then wire `expo-modules-autolinking` once
+per app. Never install `expo-linear-gradient` or the `expo` meta-package yourself.
+
+## Usage
+
+```tsx
+import { LinearGradient } from '@symbiote-native/linear-gradient/react';
+
+<LinearGradient colors={['#4c669f', '#192f6a']} start={{ x: 0, y: 0 }} end={{ x: 1, y: 1 }}>
+  <Text>Over the gradient</Text>
+</LinearGradient>;
+```
+
+Same props on every adapter: `colors` (two or more), `locations`, `start`, `end`, `dither`
+(Android), `style` and the View accessibility surface. Children come through the framework's own
+mechanism (`children`, default slot, snippet, `<ng-content>`).
+
+## Layout
+
+| Platform | Structure                                                      |
+| -------- | -------------------------------------------------------------- |
+| iOS      | the native view is the root, children are inside it           |
+| Android  | a `View` wraps an absolute-fill native leaf, children beside it |
+
+Angular cannot spell a dynamic tag name or project into a descriptor-built node, so it keeps one
+component per platform (`index.ios.ts` / `index.android.ts`) with the same inputs.
+
+## Not ported
+
+The web variant (`LinearGradient.web.tsx`) and `NativeLinearGradient` re-export: native only.

package/build/angular/index.d.ts

@@ -0,0 +1,2 @@
+export { LinearGradient } from './linear-gradient';
+export { LINEAR_GRADIENT_MODULE_NAME, linearGradientViewName, type ILinearGradientProps, type ILinearGradientPoint, type INativeLinearGradientPoint, } from '../core';

package/build/angular/index.js

@@ -0,0 +1,3 @@
+// @symbiote-native/linear-gradient/angular: компонент `LinearGradient` поверх общего ядра
+export { LinearGradient } from './linear-gradient';
+export { LINEAR_GRADIENT_MODULE_NAME, linearGradientViewName, } from '../core/index.js';

package/build/angular/linear-gradient/index.android.d.ts

@@ -0,0 +1,4 @@
+import { LinearGradientBase } from './shared';
+/** Angular twin of `expo-linear-gradient`'s `LinearGradient`, a View wraps the gradient leaf */
+export declare class LinearGradient extends LinearGradientBase {
+}

package/build/angular/linear-gradient/index.android.js

@@ -0,0 +1,65 @@
+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 } from '@angular/core';
+import { DescriptorHost } from '@symbiote-native/angular';
+import { LinearGradientBase } from './shared.js';
+/** Angular twin of `expo-linear-gradient`'s `LinearGradient`, a View wraps the gradient leaf */
+let LinearGradient = (() => {
+    let _classDecorators = [Component({
+            selector: 'LinearGradient',
+            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 = LinearGradientBase;
+    var LinearGradient = 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);
+            LinearGradient = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return LinearGradient = _classThis;
+})();
+export { LinearGradient };

package/build/angular/linear-gradient/index.d.ts

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

package/build/angular/linear-gradient/index.ios.d.ts

@@ -0,0 +1,5 @@
+import { LinearGradientBase } from './shared';
+/** Angular twin of `expo-linear-gradient`'s `LinearGradient`, children go inside the native view */
+export declare class LinearGradient extends LinearGradientBase {
+    constructor();
+}

package/build/angular/linear-gradient/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, NO_ERRORS_SCHEMA, } from '@angular/core';
+import { SymbioteHostPropsDirective } from '@symbiote-native/angular';
+import { warnIfViewNameIsDynamic } from '@symbiote-native/engine';
+import { LINEAR_GRADIENT_MODULE_NAME } from '../../core/index.js';
+import { LinearGradientBase } from './shared.js';
+const TEMPLATE_TAG = 'ViewManagerAdapter_ExpoLinearGradient';
+/** Angular twin of `expo-linear-gradient`'s `LinearGradient`, children go inside the native view */
+let LinearGradient = (() => {
+    let _classDecorators = [Component({
+            selector: 'LinearGradient',
+            standalone: true,
+            imports: [SymbioteHostPropsDirective],
+            schemas: [NO_ERRORS_SCHEMA],
+            changeDetection: ChangeDetectionStrategy.OnPush,
+            // Имя тега это нативное имя view, его нельзя собрать динамически
+            template: `@if (descriptor; as node) {
+    <ViewManagerAdapter_ExpoLinearGradient [symbioteHostProps]="node.props">
+      <ng-content />
+    </ViewManagerAdapter_ExpoLinearGradient>
+  }`,
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = LinearGradientBase;
+    var LinearGradient = 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);
+            LinearGradient = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor() {
+            super();
+            warnIfViewNameIsDynamic(TEMPLATE_TAG, LINEAR_GRADIENT_MODULE_NAME);
+        }
+    };
+    return LinearGradient = _classThis;
+})();
+export { LinearGradient };

package/build/angular/linear-gradient/index.js

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

package/build/angular/linear-gradient/shared.d.ts

@@ -0,0 +1,12 @@
+import { NativeViewBase } from '@symbiote-native/angular';
+import type { IDescriptor } from '@symbiote-native/components';
+import type { ILinearGradientProps } from '../../core/linear-gradient';
+export declare abstract class LinearGradientBase extends NativeViewBase {
+    colors: ILinearGradientProps['colors'];
+    locations?: ILinearGradientProps['locations'];
+    start?: ILinearGradientProps['start'];
+    end?: ILinearGradientProps['end'];
+    dither?: ILinearGradientProps['dither'];
+    protected readonly propNames: readonly ["colors", "locations", "start", "end", "dither"];
+    protected renderView(props: object): IDescriptor;
+}

package/build/angular/linear-gradient/shared.js

@@ -0,0 +1,97 @@
+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 { renderLinearGradient } from '../../core/linear-gradient.js';
+// Inputs и сборка дескриптора общие, платформы различаются только шаблоном
+let LinearGradientBase = (() => {
+    let _classDecorators = [Directive()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = NativeViewBase;
+    let _colors_decorators;
+    let _colors_initializers = [];
+    let _colors_extraInitializers = [];
+    let _locations_decorators;
+    let _locations_initializers = [];
+    let _locations_extraInitializers = [];
+    let _start_decorators;
+    let _start_initializers = [];
+    let _start_extraInitializers = [];
+    let _end_decorators;
+    let _end_initializers = [];
+    let _end_extraInitializers = [];
+    let _dither_decorators;
+    let _dither_initializers = [];
+    let _dither_extraInitializers = [];
+    var LinearGradientBase = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _colors_decorators = [Input({ required: true })];
+            _locations_decorators = [Input()];
+            _start_decorators = [Input()];
+            _end_decorators = [Input()];
+            _dither_decorators = [Input()];
+            __esDecorate(null, null, _colors_decorators, { kind: "field", name: "colors", static: false, private: false, access: { has: obj => "colors" in obj, get: obj => obj.colors, set: (obj, value) => { obj.colors = value; } }, metadata: _metadata }, _colors_initializers, _colors_extraInitializers);
+            __esDecorate(null, null, _locations_decorators, { kind: "field", name: "locations", static: false, private: false, access: { has: obj => "locations" in obj, get: obj => obj.locations, set: (obj, value) => { obj.locations = value; } }, metadata: _metadata }, _locations_initializers, _locations_extraInitializers);
+            __esDecorate(null, null, _start_decorators, { kind: "field", name: "start", static: false, private: false, access: { has: obj => "start" in obj, get: obj => obj.start, set: (obj, value) => { obj.start = value; } }, metadata: _metadata }, _start_initializers, _start_extraInitializers);
+            __esDecorate(null, null, _end_decorators, { kind: "field", name: "end", static: false, private: false, access: { has: obj => "end" in obj, get: obj => obj.end, set: (obj, value) => { obj.end = value; } }, metadata: _metadata }, _end_initializers, _end_extraInitializers);
+            __esDecorate(null, null, _dither_decorators, { kind: "field", name: "dither", static: false, private: false, access: { has: obj => "dither" in obj, get: obj => obj.dither, set: (obj, value) => { obj.dither = value; } }, metadata: _metadata }, _dither_initializers, _dither_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            LinearGradientBase = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        colors = __runInitializers(this, _colors_initializers, void 0);
+        locations = (__runInitializers(this, _colors_extraInitializers), __runInitializers(this, _locations_initializers, void 0));
+        start = (__runInitializers(this, _locations_extraInitializers), __runInitializers(this, _start_initializers, void 0));
+        end = (__runInitializers(this, _start_extraInitializers), __runInitializers(this, _end_initializers, void 0));
+        dither = (__runInitializers(this, _end_extraInitializers), __runInitializers(this, _dither_initializers, void 0));
+        propNames = (__runInitializers(this, _dither_extraInitializers), [
+            'colors',
+            'locations',
+            'start',
+            'end',
+            'dither',
+        ]);
+        renderView(props) {
+            return renderLinearGradient(props);
+        }
+    };
+    return LinearGradientBase = _classThis;
+})();
+export { LinearGradientBase };

package/build/core/index.d.ts

@@ -0,0 +1 @@
+export { LINEAR_GRADIENT_MODULE_NAME, ensureLinearGradientRegistered, linearGradientViewName, normalizePoint, renderLinearGradient, type ILinearGradientPoint, type ILinearGradientProps, type INativeLinearGradientPoint, } from './linear-gradient';

package/build/core/index.js

@@ -0,0 +1 @@
+export { LINEAR_GRADIENT_MODULE_NAME, ensureLinearGradientRegistered, linearGradientViewName, normalizePoint, renderLinearGradient, } from './linear-gradient.js';

package/build/core/linear-gradient.d.ts

@@ -0,0 +1,33 @@
+import type { IAccessibilityProps, IAriaProps, IDescriptor, IResponderProps } from '@symbiote-native/components';
+import type { IColorValue, IStyleProp, ISymbioteEvent, IViewStyle } from '@symbiote-native/engine';
+export declare const LINEAR_GRADIENT_MODULE_NAME = "ExpoLinearGradient";
+export type INativeLinearGradientPoint = [x: number, y: number];
+/** Доли размера градиента от 0 до 1, объект `{ x, y }` или пара `[x, y]` */
+export type ILinearGradientPoint = {
+    x: number;
+    y: number;
+} | INativeLinearGradientPoint;
+export type ILinearGradientProps = IAccessibilityProps & IAriaProps & IResponderProps & {
+    /** Минимум два цвета, для одного используйте `style.backgroundColor` у View */
+    colors: readonly [IColorValue, IColorValue, ...IColorValue[]];
+    /** Позиции остановок от 0 до 1 по возрастанию, той же длины, что и `colors` */
+    locations?: readonly [number, number, ...number[]] | null;
+    /** @default { x: 0.5, y: 0.0 } */
+    start?: ILinearGradientPoint | null;
+    /** @default { x: 0.5, y: 1.0 } */
+    end?: ILinearGradientPoint | null;
+    /**
+     * Дизеринг убирает полосы в градиенте, false может ускорить отрисовку
+     * @default true
+     * @platform android
+     */
+    dither?: boolean;
+    style?: IStyleProp<IViewStyle>;
+    testID?: string;
+    nativeID?: string;
+    onLayout?: (event: ISymbioteEvent) => void;
+};
+export declare function linearGradientViewName(): string;
+export declare function ensureLinearGradientRegistered(): boolean;
+export declare function normalizePoint(point: unknown): INativeLinearGradientPoint | undefined;
+export declare function renderLinearGradient(props: object): IDescriptor;

package/build/core/linear-gradient.js

@@ -0,0 +1,105 @@
+// Ядро `LinearGradient`, порт `LinearGradient.tsx` из expo-linear-gradient
+import { Platform, requireNativeViewManager } from 'expo-modules-core';
+import { el } from '@symbiote-native/components';
+import { expoViewManagerName, flattenStyle, processColor, styleOfProps, tryRegisterNativeView, } from '@symbiote-native/engine';
+export const LINEAR_GRADIENT_MODULE_NAME = 'ExpoLinearGradient';
+// Эти ключи разбираются здесь, остальное уходит на хост как есть
+const GRADIENT_KEYS = new Set([
+    'colors',
+    'locations',
+    'start',
+    'end',
+    'dither',
+]);
+const ABSOLUTE_FILL = {
+    position: 'absolute',
+    left: 0,
+    right: 0,
+    top: 0,
+    bottom: 0,
+};
+export function linearGradientViewName() {
+    return expoViewManagerName(LINEAR_GRADIENT_MODULE_NAME);
+}
+// Регистрирует view config в реестре RN, из него движок берёт события и процессоры пропсов
+// Зовётся при рендере, а не при импорте: регистрация в побочном эффекте барреля теряется в release
+export function ensureLinearGradientRegistered() {
+    return tryRegisterNativeView(() => requireNativeViewManager(LINEAR_GRADIENT_MODULE_NAME));
+}
+function isNumber(value) {
+    return typeof value === 'number';
+}
+export function normalizePoint(point) {
+    if (!point)
+        return undefined;
+    if (Array.isArray(point)) {
+        const [x, y] = point;
+        if (point.length === 2 && isNumber(x) && isNumber(y))
+            return [x, y];
+        console.warn('start and end props for LinearGradient must be of the format [x,y] or {x, y}');
+        return undefined;
+    }
+    const x = Reflect.get(Object(point), 'x');
+    const y = Reflect.get(Object(point), 'y');
+    return isNumber(x) && isNumber(y) ? [x, y] : undefined;
+}
+function resolveLocations(colors, locations) {
+    if (!Array.isArray(locations))
+        return undefined;
+    if (locations.length === colors.length)
+        return locations;
+    console.warn('LinearGradient colors and locations props should be arrays of the same length');
+    return locations.slice(0, colors.length);
+}
+function radiusOr(value, fallback) {
+    return isNumber(value) ? value : fallback;
+}
+// Формат из `Path.addRoundRect`: по два значения на угол, начиная с верхнего левого
+function borderRadiiOf(style) {
+    const flat = flattenStyle(style) ?? {};
+    const base = radiusOr(flat.borderRadius, 0);
+    const topLeft = radiusOr(flat.borderTopLeftRadius, base);
+    const topRight = radiusOr(flat.borderTopRightRadius, base);
+    const bottomRight = radiusOr(flat.borderBottomRightRadius, base);
+    const bottomLeft = radiusOr(flat.borderBottomLeftRadius, base);
+    return [
+        topLeft,
+        topLeft,
+        topRight,
+        topRight,
+        bottomRight,
+        bottomRight,
+        bottomLeft,
+        bottomLeft,
+    ];
+}
+function withoutUndefined(props) {
+    return Object.fromEntries(Object.entries(props).filter(([, value]) => value !== undefined));
+}
+// `object`, а не тип пропсов: Vue и Angular отдают нетипизированный набор атрибутов
+export function renderLinearGradient(props) {
+    const hostProps = Object.fromEntries(Object.entries(props).filter(([key]) => !GRADIENT_KEYS.has(key)));
+    if (!ensureLinearGradientRegistered()) {
+        console.warn('LinearGradient is not available on this platform');
+        return el('view', hostProps);
+    }
+    const colors = Reflect.get(props, 'colors');
+    const colorList = Array.isArray(colors) ? colors : [];
+    const nativeProps = withoutUndefined({
+        colors: colorList.map(color => processColor(color)),
+        locations: resolveLocations(colorList, Reflect.get(props, 'locations')),
+        startPoint: normalizePoint(Reflect.get(props, 'start')),
+        endPoint: normalizePoint(Reflect.get(props, 'end')),
+    });
+    if (!Platform.select({ android: true, default: false })) {
+        return el(linearGradientViewName(), { ...hostProps, ...nativeProps });
+    }
+    // Нативный градиент заполняет View и сам скругляет углы, т.к. RN не обрезает по радиусу
+    const native = el(linearGradientViewName(), withoutUndefined({
+        ...nativeProps,
+        style: ABSOLUTE_FILL,
+        borderRadii: borderRadiiOf(styleOfProps(props)),
+        dither: Reflect.get(props, 'dither'),
+    }));
+    return el('view', hostProps, [native]);
+}

package/build/react/index.d.ts

@@ -0,0 +1,3 @@
+export { LinearGradient } from './linear-gradient';
+export type { ILinearGradientProps } from './linear-gradient';
+export { LINEAR_GRADIENT_MODULE_NAME, linearGradientViewName, type ILinearGradientPoint, type INativeLinearGradientPoint, } from '../core';

package/build/react/index.js

@@ -0,0 +1,3 @@
+// @symbiote-native/linear-gradient/react: компонент `LinearGradient` поверх общего ядра
+export { LinearGradient } from './linear-gradient.js';
+export { LINEAR_GRADIENT_MODULE_NAME, linearGradientViewName, } from '../core/index.js';

package/build/react/linear-gradient.d.ts

@@ -0,0 +1,9 @@
+import type { ReactElement, ReactNode } from 'react';
+import type { IViewProps } from '@symbiote-native/react';
+import type { ILinearGradientProps as ILinearGradientBaseProps } from '../core/linear-gradient';
+export type ILinearGradientProps = ILinearGradientBaseProps & Omit<IViewProps, keyof ILinearGradientBaseProps | 'children'> & {
+    children?: ReactNode;
+    className?: string;
+};
+/** React twin of `expo-linear-gradient`'s `LinearGradient`, children paint over the gradient */
+export declare function LinearGradient(props: ILinearGradientProps): ReactElement;

package/build/react/linear-gradient.js

@@ -0,0 +1,7 @@
+import { descriptorToReactWithChildren } from '@symbiote-native/react';
+import { renderLinearGradient } from '../core/linear-gradient.js';
+/** React twin of `expo-linear-gradient`'s `LinearGradient`, children paint over the gradient */
+export function LinearGradient(props) {
+    const { children, ...rest } = props;
+    return descriptorToReactWithChildren(renderLinearGradient(rest), children);
+}

package/build/solid/index.d.ts

@@ -0,0 +1,3 @@
+export { LinearGradient } from './linear-gradient';
+export type { ILinearGradientProps } from './linear-gradient';
+export { LINEAR_GRADIENT_MODULE_NAME, linearGradientViewName, type ILinearGradientPoint, type INativeLinearGradientPoint, } from '../core';

package/build/solid/index.js

@@ -0,0 +1,3 @@
+// @symbiote-native/linear-gradient/solid: компонент `LinearGradient` поверх общего ядра
+export { LinearGradient } from './linear-gradient.js';
+export { LINEAR_GRADIENT_MODULE_NAME, linearGradientViewName, } from '../core/index.js';

package/build/solid/linear-gradient.d.ts

@@ -0,0 +1,10 @@
+import type { JSX } from 'solid-js';
+import type { IViewProps } from '@symbiote-native/solid';
+import type { IClassNameValue } from '@symbiote-native/engine';
+import type { ILinearGradientProps as ILinearGradientBaseProps } from '../core/linear-gradient';
+export type ILinearGradientProps = ILinearGradientBaseProps & Omit<IViewProps, keyof ILinearGradientBaseProps | 'children' | 'ref'> & {
+    children?: JSX.Element;
+    class?: IClassNameValue;
+};
+/** Solid twin of `expo-linear-gradient`'s `LinearGradient`, children paint over the gradient */
+export declare const LinearGradient: (props: ILinearGradientProps) => import("@symbiote-native/engine").ISymbioteNode;

package/build/solid/linear-gradient.js

@@ -0,0 +1,4 @@
+import { defineDescriptorComponent } from '@symbiote-native/solid';
+import { renderLinearGradient } from '../core/linear-gradient.js';
+/** Solid twin of `expo-linear-gradient`'s `LinearGradient`, children paint over the gradient */
+export const LinearGradient = defineDescriptorComponent(renderLinearGradient);

package/build/svelte/index.d.ts

@@ -0,0 +1,3 @@
+export { default as LinearGradient } from './linear-gradient.svelte';
+export type { ILinearGradientProps } from './linear-gradient-props';
+export { LINEAR_GRADIENT_MODULE_NAME, linearGradientViewName, type ILinearGradientPoint, type INativeLinearGradientPoint, } from '../core';

package/build/svelte/index.js

@@ -0,0 +1,3 @@
+// @symbiote-native/linear-gradient/svelte: компонент `LinearGradient` поверх общего ядра
+export { default as LinearGradient } from './linear-gradient.svelte';
+export { LINEAR_GRADIENT_MODULE_NAME, linearGradientViewName, } from '../core/index.js';

package/build/svelte/linear-gradient-props.d.ts

@@ -0,0 +1,6 @@
+import type { Snippet } from 'svelte';
+import type { IViewProps } from '@symbiote-native/svelte';
+import type { ILinearGradientProps as ILinearGradientBaseProps } from '../core/linear-gradient';
+export type ILinearGradientProps = ILinearGradientBaseProps & Omit<IViewProps, keyof ILinearGradientBaseProps | 'children'> & {
+    children?: Snippet;
+};

package/build/svelte/linear-gradient-props.js

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

package/build/svelte/linear-gradient.svelte

@@ -0,0 +1,10 @@
+<script lang="ts">
+  import DescriptorHost from '@symbiote-native/svelte/descriptor-host';
+  import { renderLinearGradient } from '../core/linear-gradient';
+  import type { ILinearGradientProps } from './linear-gradient-props';
+
+  const { children, ...rest }: ILinearGradientProps = $props();
+  const descriptor = $derived(renderLinearGradient({ ...rest }));
+</script>
+
+<DescriptorHost {descriptor} {children} />

package/build/svelte/linear-gradient.svelte.d.ts

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

package/build/vue/index.d.ts

@@ -0,0 +1,3 @@
+export { LinearGradient } from './linear-gradient';
+export type { ILinearGradientProps } from './linear-gradient';
+export { LINEAR_GRADIENT_MODULE_NAME, linearGradientViewName, type ILinearGradientPoint, type INativeLinearGradientPoint, } from '../core';

package/build/vue/index.js

@@ -0,0 +1,3 @@
+// @symbiote-native/linear-gradient/vue: компонент `LinearGradient` поверх общего ядра
+export { LinearGradient } from './linear-gradient.js';
+export { LINEAR_GRADIENT_MODULE_NAME, linearGradientViewName, } from '../core/index.js';

package/build/vue/linear-gradient.d.ts

@@ -0,0 +1,6 @@
+import { type VNode } from '@vue/runtime-core';
+import type { IViewProps } from '@symbiote-native/vue';
+import type { ILinearGradientProps as ILinearGradientBaseProps } from '../core/linear-gradient';
+export type ILinearGradientProps = ILinearGradientBaseProps & Omit<IViewProps, keyof ILinearGradientBaseProps>;
+/** Vue twin of `expo-linear-gradient`'s `LinearGradient`, the default slot paints over it */
+export declare const LinearGradient: 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/linear-gradient.js

@@ -0,0 +1,16 @@
+import { defineComponent } from '@vue/runtime-core';
+import { descriptorToVue, normalizeVueAttrs } from '@symbiote-native/vue';
+import { renderLinearGradient } from '../core/linear-gradient.js';
+/** Vue twin of `expo-linear-gradient`'s `LinearGradient`, the default slot paints over it */
+export const LinearGradient = defineComponent({
+    name: 'LinearGradient',
+    // Все атрибуты это пропсы нативного view, на обёртку ничего не должно просочиться
+    inheritAttrs: false,
+    setup(_props, { attrs, slots }) {
+        return () => {
+            const descriptor = renderLinearGradient(normalizeVueAttrs(attrs));
+            // Слот приложения идёт в корень после собственных детей дескриптора
+            return descriptorToVue(descriptor, slots.default?.() ?? []);
+        };
+    },
+});