@symbiote-native/image-manipulator 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

@@ -0,0 +1,154 @@
+# @symbiote-native/image-manipulator
+
+Shrink a photo before uploading it, rotate a scan, crop an avatar: build a chain of edits, render
+once, save to a new file. One API for every [SymbioteNative](../../README.md) adapter (React, Vue,
+Svelte, Solid and Angular).
+
+It wraps [`expo-image-manipulator`](https://github.com/expo/expo/tree/main/packages/expo-image-manipulator)
+the same way [`@symbiote-native/print`](../print) wraps its upstream: `expo-modules-core` is a
+direct dependency, never the `expo` meta-package, and the upstream JS is hand-ported into `core/`.
+The mechanics live in the `symbiote-expo-native-module` project skill.
+
+## Install
+
+**New app:**
+
+```bash
+npx @symbiote-native/cli new my-app --image-manipulator
+```
+
+**Existing SymbioteNative app:**
+
+```bash
+npx @symbiote-native/cli add --image-manipulator
+```
+
+Either way: installs `@symbiote-native/image-manipulator` 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/image-manipulator
+```
+
+`expo-image-manipulator` and `expo-modules-core` come along as regular, pinned dependencies -
+never install either yourself, and never add the `expo` meta-package to this project.
+
+### Required one-time step: native autolinking wiring
+
+Same one-time app wiring every `expo-modules-core` package shares - see
+[`@symbiote-native/print`'s README](../print/README.md#required-one-time-step-native-autolinking-wiring)
+for the full table; nothing package-specific here.
+
+### No permissions, no config plugin
+
+- **No runtime permission on either platform.** The module only ever touches a URI/file the
+  caller already has access to - no camera, no photo library.
+- **No manifest edit.** `expo-image-manipulator`'s own `AndroidManifest.xml` declares nothing.
+- **No config plugin.** Upstream ships none.
+
+</details>
+
+## Shape
+
+```
+src/core/                 manipulate + manipulateAsync + FlipType + SaveFormat + the shared
+                          releasing-context controller. native-module.ts resolves
+                          ExpoImageManipulator through expo-modules-core's requireNativeModule.
+src/react/                useImageManipulator (hook)
+src/vue/                  useImageManipulator (composable)
+src/solid/                useImageManipulator (primitive)
+src/svelte/               useImageManipulator (rune)
+src/angular/              injectImageManipulator
+```
+
+`manipulate`/`manipulateAsync`/`FlipType`/`SaveFormat` stay framework-agnostic free functions,
+re-exported by every adapter's own barrel. Upstream's `useImageManipulator` is ported to
+**every** adapter, not just React: the recreate/release rule lives once in
+`src/core/manipulator-context-controller.ts`, each adapter supplies only its own reactive
+lifecycle, per this project's `components_split_logic_view_lifecycle` convention.
+
+## Use it
+
+The current, chainable API (mirrors upstream's `ImageManipulator.manipulate`/`ImageManipulatorContext`):
+
+```ts
+import { manipulate } from '@symbiote-native/image-manipulator';
+
+const context = manipulate('file:///photo.jpg');
+context.resize({ width: 300 }).rotate(90);
+const image = await context.renderAsync();
+const { uri, width, height } = await image.saveAsync({ format: 'jpeg', compress: 0.8 });
+
+// Free the native memory once done - no lifecycle wrapper here (framework-agnostic core), each
+// adapter's own hook/composable/service is responsible for calling `.release()` on unmount.
+context.release();
+image.release();
+```
+
+The deprecated, one-shot API (kept for parity - upstream still ships it too):
+
+```ts
+import { manipulateAsync, SaveFormat } from '@symbiote-native/image-manipulator';
+
+const { uri } = await manipulateAsync(
+  'file:///photo.jpg',
+  [{ resize: { width: 300 } }, { rotate: 90 }],
+  { format: SaveFormat.JPEG, compress: 0.8 },
+);
+```
+
+## API
+
+| Export            | Signature                                                                | Notes                                          |
+| ------------------ | ------------------------------------------------------------------------ | ----------------------------------------------- |
+| `manipulate`       | `(source: string \| IImageRef) => IImageManipulatorContext`              | Chainable `resize`/`rotate`/`flip`/`crop`/`reset`/`renderAsync`. |
+| `manipulateAsync`  | `(uri, actions?, saveOptions?) => Promise<IImageResult>`                  | @deprecated - replaced by `manipulate`.        |
+| `FlipType`         | `{ Vertical, Horizontal }`                                                | Enum for the `flip` action.                    |
+| `SaveFormat`       | `{ JPEG, PNG, WEBP }`                                                     | Enum for `ISaveOptions.format`.                |
+
+## Declarative `useImageManipulator`
+
+```
+useImageManipulator(source) -> IImageManipulatorContext
+```
+
+React takes a plain value, re-invoked per render (matches upstream exactly). Vue/Solid/Svelte
+take a reactive source (`Ref`/getter/`MaybeRefOrGetter`/accessor) so switching it recreates the
+context and releases the stale one. Angular's `injectImageManipulator(source)` takes a `Signal`
+and returns one, `injectX` shape matching `@symbiote-native/navigation`'s
+`injectLinkingIntegration`.
+
+## Notes
+
+- **Release what you create outside a component.** `manipulate()` and `renderAsync()` hold native
+  memory until `release()`. The adapter bindings release on unmount; the free function does not.
+- **`extent` action is not ported.** It's web-only in upstream - neither the iOS nor the Android
+  native module registers an `extent` function (verified by reading both `ImageManipulatorModule`
+  sources). Calling `.extent()` on a native context is a type error here, matching runtime reality.
+- **`ImageManipulator.Image` (the hidden native class property) is not exposed.** Upstream itself
+  marks it `@hidden` - only reachable indirectly via `context.renderAsync()`'s resolved `IImageRef`.
+
+## Common questions
+
+- **Smaller upload.** Resize first (`resize({ width: 1080 })`), then
+  `saveAsync({ format: SaveFormat.JPEG, compress: 0.7 })`; `compress` is 0 to 1 and applies to JPEG
+  and WebP, PNG is lossless.
+- **Keep the aspect ratio.** Give only one of `width` and `height`.
+- **Memory growth.** `manipulate()` and `renderAsync()` hold native memory until `release()`.
+- **`manipulateAsync`.** Works but deprecated upstream; use `manipulate()`.
+
+Sources: [Expo docs: ImageManipulator](https://docs.expo.dev/versions/latest/sdk/imagemanipulator/),
+[expo/expo#2512](https://github.com/expo/expo/issues/2512).
+
+## Test it
+
+```bash
+pnpm vitest run packages/image-manipulator
+```
+
+Upstream ships one test suite, `src/__tests__/validators-test.ts` - ported to
+`validators.test.ts` (minus the `extent` cases, see above). `image-manipulator.test.ts` is net-new
+coverage of `manipulate`/`manipulateAsync` against a faked native module.

package/build/angular/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { injectImageManipulator } from './inject-image-manipulator';

package/build/angular/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { injectImageManipulator } from './inject-image-manipulator.js';

package/build/angular/inject-image-manipulator.d.ts

@@ -0,0 +1,3 @@
+import type { Signal } from '@angular/core';
+import type { IImageManipulatorContext, IImageRef } from '../core';
+export declare function injectImageManipulator(source: () => string | IImageRef): Signal<IImageManipulatorContext>;

package/build/angular/inject-image-manipulator.js

@@ -0,0 +1,8 @@
+// Angular twin of `useImageManipulator`, `injectX` shape matching
+// `@symbiote-native/navigation`'s `injectLinkingIntegration`
+import { createResourceHook } from '@symbiote-native/angular';
+import { createImageManipulatorResourceController } from '../core/manipulator-resource-controller.js';
+const injectManipulatorResource = createResourceHook(createImageManipulatorResourceController);
+export function injectImageManipulator(source) {
+    return injectManipulatorResource(() => [source()]);
+}

package/build/core/image-manipulator.d.ts

@@ -0,0 +1,10 @@
+import type { NativeImageManipulatorContext, NativeImageRef } from './native-module';
+import type { IAction, IImageResult, ISaveOptions } from './types';
+export type { NativeImageManipulatorContext as IImageManipulatorContext };
+export type { NativeImageRef as IImageRef };
+/** Loads `source` and starts a new chainable manipulation context. */
+export declare function manipulate(source: string | NativeImageRef): NativeImageManipulatorContext;
+/**
+ * @deprecated replaced by `manipulate(source)` / the returned context's chainable methods.
+ */
+export declare function manipulateAsync(uri: string, actions?: IAction[], saveOptions?: ISaveOptions): Promise<IImageResult>;

package/build/core/image-manipulator.js

@@ -0,0 +1,34 @@
+import { expoImageManipulator } from './native-module.js';
+import { SaveFormat } from './types.js';
+import { validateArguments } from './validators.js';
+/** Loads `source` and starts a new chainable manipulation context. */
+export function manipulate(source) {
+    return expoImageManipulator.manipulate(source);
+}
+/**
+ * @deprecated replaced by `manipulate(source)` / the returned context's chainable methods.
+ */
+export async function manipulateAsync(uri, actions = [], saveOptions = {}) {
+    validateArguments(uri, actions, saveOptions);
+    const { format = SaveFormat.JPEG, ...rest } = saveOptions;
+    const context = expoImageManipulator.manipulate(uri);
+    for (const action of actions) {
+        if ('resize' in action) {
+            context.resize(action.resize);
+        }
+        else if ('rotate' in action) {
+            context.rotate(action.rotate);
+        }
+        else if ('flip' in action) {
+            context.flip(action.flip);
+        }
+        else if ('crop' in action) {
+            context.crop(action.crop);
+        }
+    }
+    const image = await context.renderAsync();
+    const result = await image.saveAsync({ format, ...rest });
+    context.release();
+    image.release();
+    return result;
+}

package/build/core/index.d.ts

@@ -0,0 +1,4 @@
+export { manipulate, manipulateAsync } from './image-manipulator';
+export type { IImageManipulatorContext, IImageRef } from './image-manipulator';
+export { FlipType, SaveFormat } from './types';
+export type { IAction, IActionCrop, IActionFlip, IActionResize, IActionRotate, IImageResult, ISaveOptions, } from './types';

package/build/core/index.js

@@ -0,0 +1,2 @@
+export { manipulate, manipulateAsync } from './image-manipulator.js';
+export { FlipType, SaveFormat } from './types.js';

package/build/core/manipulator-context-controller.d.ts

@@ -0,0 +1,9 @@
+export type IReleasableContext = {
+    release: () => void;
+};
+export type IManipulatorContextController<TSource, TContext extends IReleasableContext> = {
+    resolve: (source: TSource) => TContext;
+    flushRelease: () => void;
+    release: () => void;
+};
+export declare function createManipulatorContextController<TSource, TContext extends IReleasableContext>(manipulate: (source: TSource) => TContext): IManipulatorContextController<TSource, TContext>;

package/build/core/manipulator-context-controller.js

@@ -0,0 +1,13 @@
+// Thin binding of `@symbiote-native/engine`'s generic `createResourceController` to this
+// package's own `.release()`-shaped context, kept for its own descriptive type names
+import { createResourceController } from '@symbiote-native/engine';
+export function createManipulatorContextController(manipulate) {
+    const controller = createResourceController(manipulate, context => {
+        context.release();
+    });
+    return {
+        resolve: controller.resolve,
+        flushRelease: controller.flushDispose,
+        release: controller.dispose,
+    };
+}

package/build/core/manipulator-resource-controller.d.ts

@@ -0,0 +1,6 @@
+import type { IImageManipulatorContext, IImageRef } from './index';
+export declare function createImageManipulatorResourceController(): {
+    resolve: (source: string | IImageRef) => IImageManipulatorContext;
+    flushDispose: () => void;
+    dispose: () => void;
+};

package/build/core/manipulator-resource-controller.js

@@ -0,0 +1,17 @@
+// Adapts `createManipulatorContextController`'s `.release()`-shaped controller to the
+// `resolve`/`flushDispose`/`dispose` shape every adapter's `createResourceHook` expects
+import { createManipulatorContextController, } from './manipulator-context-controller.js';
+import { manipulate } from './index.js';
+function createManipulatorResourceController(manipulateSource) {
+    const controller = createManipulatorContextController(manipulateSource);
+    return {
+        resolve: controller.resolve,
+        flushDispose: controller.flushRelease,
+        dispose: controller.release,
+    };
+}
+// Bakes in this package's own `manipulate`, so every adapter's `createResourceHook` binds a
+// plain zero-arg factory instead of repeating the same arrow wrapper five times
+export function createImageManipulatorResourceController() {
+    return createManipulatorResourceController(manipulate);
+}

package/build/core/native-module.d.ts

@@ -0,0 +1,27 @@
+import { SharedObject, SharedRef } from 'expo-modules-core';
+import type { IImageResult, ISaveOptions } from './types';
+export declare class NativeImageRef extends SharedRef<'image'> {
+    width: number;
+    height: number;
+    saveAsync(options?: ISaveOptions): Promise<IImageResult>;
+}
+export declare class NativeImageManipulatorContext extends SharedObject {
+    resize(size: {
+        width?: number | null;
+        height?: number | null;
+    }): NativeImageManipulatorContext;
+    rotate(degrees: number): NativeImageManipulatorContext;
+    flip(flipType: 'vertical' | 'horizontal'): NativeImageManipulatorContext;
+    crop(rect: {
+        originX: number;
+        originY: number;
+        width: number;
+        height: number;
+    }): NativeImageManipulatorContext;
+    reset(): NativeImageManipulatorContext;
+    renderAsync(): Promise<NativeImageRef>;
+}
+export type INativeImageManipulatorModule = {
+    manipulate(source: string | NativeImageRef): NativeImageManipulatorContext;
+};
+export declare const expoImageManipulator: INativeImageManipulatorModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule, SharedObject, SharedRef, } from 'expo-modules-core';
+const EXPO_IMAGE_MANIPULATOR_MODULE_NAME = 'ExpoImageManipulator';
+export const expoImageManipulator = requireNativeModule(EXPO_IMAGE_MANIPULATOR_MODULE_NAME);

package/build/core/types.d.ts

@@ -0,0 +1,47 @@
+export declare enum FlipType {
+    Vertical = "vertical",
+    Horizontal = "horizontal"
+}
+export declare enum SaveFormat {
+    JPEG = "jpeg",
+    PNG = "png",
+    WEBP = "webp"
+}
+export type IActionResize = {
+    /** Provide only one of `width`/`height` to preserve the image's ratio. */
+    resize: {
+        width?: number;
+        height?: number;
+    };
+};
+export type IActionRotate = {
+    /** Degrees, clockwise when positive, counter-clockwise when negative. */
+    rotate: number;
+};
+export type IActionFlip = {
+    flip: FlipType;
+};
+export type IActionCrop = {
+    crop: {
+        originX: number;
+        originY: number;
+        width: number;
+        height: number;
+    };
+};
+/** @deprecated use `manipulate(source)` instead. */
+export type IAction = IActionResize | IActionRotate | IActionFlip | IActionCrop;
+export type ISaveOptions = {
+    base64?: boolean;
+    /** `0.0`-`1.0`; `1` is no compression (highest quality). Default `1`. */
+    compress?: number;
+    /** Default `SaveFormat.JPEG`. */
+    format?: SaveFormat;
+};
+export type IImageResult = {
+    uri: string;
+    width: number;
+    height: number;
+    /** Set only when `base64` was truthy in `ISaveOptions`. */
+    base64?: string;
+};

package/build/core/types.js

@@ -0,0 +1,11 @@
+export var FlipType;
+(function (FlipType) {
+    FlipType["Vertical"] = "vertical";
+    FlipType["Horizontal"] = "horizontal";
+})(FlipType || (FlipType = {}));
+export var SaveFormat;
+(function (SaveFormat) {
+    SaveFormat["JPEG"] = "jpeg";
+    SaveFormat["PNG"] = "png";
+    SaveFormat["WEBP"] = "webp";
+})(SaveFormat || (SaveFormat = {}));

package/build/core/validators.d.ts

@@ -0,0 +1,5 @@
+import type { IAction, ISaveOptions } from './types';
+export declare function validateArguments(uri: string, actions: IAction[], saveOptions: ISaveOptions): void;
+export declare function validateUri(uri: string): void;
+export declare function validateActions(actions: IAction[]): void;
+export declare function validateSaveOptions({ base64, compress, format, }: ISaveOptions): void;

package/build/core/validators.js

@@ -0,0 +1,92 @@
+import { FlipType, SaveFormat } from './types.js';
+const SUPPORTED_ACTION_TYPES = ['crop', 'flip', 'rotate', 'resize'];
+export function validateArguments(uri, actions, saveOptions) {
+    validateUri(uri);
+    validateActions(actions);
+    validateSaveOptions(saveOptions);
+}
+export function validateUri(uri) {
+    if (typeof uri !== 'string') {
+        throw new TypeError('The "uri" argument must be a string');
+    }
+}
+export function validateActions(actions) {
+    if (!Array.isArray(actions)) {
+        throw new TypeError('The "actions" argument must be an array');
+    }
+    for (const action of actions) {
+        if (typeof action !== 'object' || action === null) {
+            throw new TypeError('Action must be an object');
+        }
+        const actionKeys = Object.keys(action);
+        if (actionKeys.length !== 1) {
+            throw new TypeError(`Single action must contain exactly one transformation: ${SUPPORTED_ACTION_TYPES.join(', ')}`);
+        }
+        const actionType = actionKeys[0];
+        if (!SUPPORTED_ACTION_TYPES.includes(actionType)) {
+            throw new TypeError(`Unsupported action type: ${actionType}`);
+        }
+        if ('crop' in action) {
+            validateCropAction(action);
+        }
+        else if ('flip' in action) {
+            validateFlipAction(action);
+        }
+        else if ('rotate' in action) {
+            validateRotateAction(action);
+        }
+        else if ('resize' in action) {
+            validateResizeAction(action);
+        }
+    }
+}
+function validateCropAction(action) {
+    const isValid = typeof action.crop === 'object' &&
+        action.crop !== null &&
+        typeof action.crop.originX === 'number' &&
+        typeof action.crop.originY === 'number' &&
+        typeof action.crop.width === 'number' &&
+        typeof action.crop.height === 'number';
+    if (!isValid) {
+        throw new TypeError('Crop action must be an object of shape { originX: number; originY: number; width: number; height: number }');
+    }
+}
+function validateFlipAction(action) {
+    if (typeof action.flip !== 'string' ||
+        ![FlipType.Horizontal, FlipType.Vertical].includes(action.flip)) {
+        throw new TypeError(`Unsupported flip type: ${action.flip}`);
+    }
+}
+function validateRotateAction(action) {
+    if (typeof action.rotate !== 'number') {
+        throw new TypeError('Rotation must be a number');
+    }
+}
+function validateResizeAction(action) {
+    const isValid = typeof action.resize === 'object' &&
+        action.resize !== null &&
+        (typeof action.resize.width === 'number' ||
+            action.resize.width === undefined) &&
+        (typeof action.resize.height === 'number' ||
+            action.resize.height === undefined);
+    if (!isValid) {
+        throw new TypeError('Resize action must be an object of shape { width?: number; height?: number }');
+    }
+}
+export function validateSaveOptions({ base64, compress, format, }) {
+    if (base64 !== undefined && typeof base64 !== 'boolean') {
+        throw new TypeError('The "base64" argument must be a boolean');
+    }
+    if (compress !== undefined) {
+        if (typeof compress !== 'number') {
+            throw new TypeError('The "compress" argument must be a number');
+        }
+        if (compress < 0 || compress > 1) {
+            throw new TypeError('The "compress" argument must be a number between 0 and 1');
+        }
+    }
+    const allowedFormats = [SaveFormat.JPEG, SaveFormat.PNG, SaveFormat.WEBP];
+    if (format !== undefined && !allowedFormats.includes(format)) {
+        throw new TypeError(`The "format" argument must be one of: ${allowedFormats.join(', ')}`);
+    }
+}

package/build/react/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useImageManipulator } from './use-image-manipulator';

package/build/react/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { useImageManipulator } from './use-image-manipulator.js';

package/build/react/use-image-manipulator.d.ts

@@ -0,0 +1,3 @@
+import type { IImageManipulatorContext, IImageRef } from '../core';
+/** React twin of `expo-image-manipulator`'s `useImageManipulator` */
+export declare function useImageManipulator(source: string | IImageRef): IImageManipulatorContext;

package/build/react/use-image-manipulator.js

@@ -0,0 +1,7 @@
+import { createResourceHook } from '@symbiote-native/react';
+import { createImageManipulatorResourceController } from '../core/manipulator-resource-controller.js';
+const useManipulatorResource = createResourceHook(createImageManipulatorResourceController);
+/** React twin of `expo-image-manipulator`'s `useImageManipulator` */
+export function useImageManipulator(source) {
+    return useManipulatorResource(source);
+}

package/build/solid/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useImageManipulator } from './use-image-manipulator';

package/build/solid/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { useImageManipulator } from './use-image-manipulator.js';

package/build/solid/use-image-manipulator.d.ts

@@ -0,0 +1,4 @@
+import type { Accessor } from 'solid-js';
+import type { IImageManipulatorContext, IImageRef } from '../core';
+/** Solid twin of `expo-image-manipulator`'s `useImageManipulator` */
+export declare function useImageManipulator(source: Accessor<string | IImageRef>): Accessor<IImageManipulatorContext>;

package/build/solid/use-image-manipulator.js

@@ -0,0 +1,7 @@
+import { createResourceHook } from '@symbiote-native/solid';
+import { createImageManipulatorResourceController } from '../core/manipulator-resource-controller.js';
+const useManipulatorResource = createResourceHook(createImageManipulatorResourceController);
+/** Solid twin of `expo-image-manipulator`'s `useImageManipulator` */
+export function useImageManipulator(source) {
+    return useManipulatorResource(() => [source()]);
+}

package/build/svelte/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useImageManipulator } from './use-image-manipulator.svelte';

package/build/svelte/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { useImageManipulator } from './use-image-manipulator.svelte';

package/build/svelte/use-image-manipulator.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { IImageManipulatorContext, IImageRef } from '../core';
+export type IUseImageManipulatorResult = {
+    readonly current: IImageManipulatorContext;
+};
+export declare function useImageManipulator(getSource: () => string | IImageRef): IUseImageManipulatorResult;

package/build/svelte/use-image-manipulator.svelte.js

@@ -0,0 +1,7 @@
+// Svelte twin of `expo-image-manipulator`'s `useImageManipulator`
+import { createResourceHook } from '@symbiote-native/svelte/runes/create-resource-hook';
+import { createImageManipulatorResourceController } from '../core/manipulator-resource-controller.js';
+const useManipulatorResource = createResourceHook(createImageManipulatorResourceController);
+export function useImageManipulator(getSource) {
+    return useManipulatorResource(() => [getSource()]);
+}

package/build/vue/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useImageManipulator } from './use-image-manipulator';

package/build/vue/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { useImageManipulator } from './use-image-manipulator.js';

package/build/vue/use-image-manipulator.d.ts

@@ -0,0 +1,4 @@
+import { type ComputedRef, type MaybeRefOrGetter } from '@vue/runtime-core';
+import type { IImageManipulatorContext, IImageRef } from '../core';
+/** Vue twin of `expo-image-manipulator`'s `useImageManipulator` */
+export declare function useImageManipulator(source: MaybeRefOrGetter<string | IImageRef>): ComputedRef<IImageManipulatorContext>;

package/build/vue/use-image-manipulator.js

@@ -0,0 +1,8 @@
+import { toValue, } from '@vue/runtime-core';
+import { createResourceHook } from '@symbiote-native/vue';
+import { createImageManipulatorResourceController } from '../core/manipulator-resource-controller.js';
+const useManipulatorResource = createResourceHook(createImageManipulatorResourceController);
+/** Vue twin of `expo-image-manipulator`'s `useImageManipulator` */
+export function useImageManipulator(source) {
+    return useManipulatorResource(() => [toValue(source)]);
+}

package/build-ngc/angular/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { injectImageManipulator } from './inject-image-manipulator';

package/build-ngc/angular/index.js

@@ -0,0 +1,3 @@
+export * from '../core';
+export { injectImageManipulator } from './inject-image-manipulator';
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC"}

package/build-ngc/angular/inject-image-manipulator.d.ts

@@ -0,0 +1,3 @@
+import type { Signal } from '@angular/core';
+import type { IImageManipulatorContext, IImageRef } from '../core';
+export declare function injectImageManipulator(source: () => string | IImageRef): Signal<IImageManipulatorContext>;

package/build-ngc/angular/inject-image-manipulator.js

@@ -0,0 +1,9 @@
+// Angular twin of `useImageManipulator`, `injectX` shape matching
+// `@symbiote-native/navigation`'s `injectLinkingIntegration`
+import { createResourceHook } from '@symbiote-native/angular';
+import { createImageManipulatorResourceController } from '../core/manipulator-resource-controller';
+const injectManipulatorResource = createResourceHook(createImageManipulatorResourceController);
+export function injectImageManipulator(source) {
+    return injectManipulatorResource(() => [source()]);
+}
+//# sourceMappingURL=inject-image-manipulator.js.map

package/build-ngc/angular/inject-image-manipulator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inject-image-manipulator.js","sourceRoot":"","sources":["../../src/angular/inject-image-manipulator.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,6DAA6D;AAG7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,EAAE,wCAAwC,EAAE,MAAM,yCAAyC,CAAC;AAEnG,MAAM,yBAAyB,GAAG,kBAAkB,CAClD,wCAAwC,CACzC,CAAC;AAEF,MAAM,UAAU,sBAAsB,CACpC,MAAgC;IAEhC,OAAO,yBAAyB,CAAC,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;AACrD,CAAC"}

package/build-ngc/core/image-manipulator.d.ts

@@ -0,0 +1,10 @@
+import type { NativeImageManipulatorContext, NativeImageRef } from './native-module';
+import type { IAction, IImageResult, ISaveOptions } from './types';
+export type { NativeImageManipulatorContext as IImageManipulatorContext };
+export type { NativeImageRef as IImageRef };
+/** Loads `source` and starts a new chainable manipulation context. */
+export declare function manipulate(source: string | NativeImageRef): NativeImageManipulatorContext;
+/**
+ * @deprecated replaced by `manipulate(source)` / the returned context's chainable methods.
+ */
+export declare function manipulateAsync(uri: string, actions?: IAction[], saveOptions?: ISaveOptions): Promise<IImageResult>;