@symbiote-native/asset 0.1.0

package/src/core/native-module.ts

@@ -0,0 +1,11 @@
+import { requireNativeModule } from 'expo-modules-core';
+
+export type INativeAssetModule = {
+  downloadAsync(
+    url: string,
+    md5Hash: string | null,
+    type: string,
+  ): Promise<string>;
+};
+
+export const expoAsset = requireNativeModule<INativeAssetModule>('ExpoAsset');

package/src/core/platform-utils.ts

@@ -0,0 +1,47 @@
+// Ported from expo-asset/src/PlatformUtils.ts (sdk-57) — real logic, not a stub. Every check
+// here (ExpoGo/expo-updates native modules, the classic-updates manifest) naturally resolves to
+// "absent" in a bare app that ships neither, matching upstream's own designed fallback.
+import Constants from 'expo-constants';
+import {
+  requireNativeModule,
+  requireOptionalNativeModule,
+} from 'expo-modules-core';
+
+import { getManifestBaseUrl } from './asset-uris';
+
+type IExpoUpdatesModule = {
+  isEnabled?: boolean;
+  isUsingEmbeddedAssets?: boolean;
+  localAssets?: Record<string, string>;
+};
+
+const ExpoUpdates =
+  requireOptionalNativeModule<IExpoUpdatesModule>('ExpoUpdates');
+
+function isRunningInExpoGo(): boolean {
+  try {
+    return requireNativeModule('ExpoGo') != null;
+  } catch {
+    return false;
+  }
+}
+
+const expoUpdatesIsInstalledAndEnabled = !!ExpoUpdates?.isEnabled;
+const expoUpdatesIsUsingEmbeddedAssets = ExpoUpdates?.isUsingEmbeddedAssets;
+const shouldUseUpdatesAssetResolution =
+  expoUpdatesIsInstalledAndEnabled && !expoUpdatesIsUsingEmbeddedAssets;
+
+export const IS_ENV_WITH_LOCAL_ASSETS =
+  isRunningInExpoGo() || shouldUseUpdatesAssetResolution;
+
+export function getLocalAssets(): Record<string, string> {
+  return ExpoUpdates?.localAssets ?? {};
+}
+
+export function getManifest2(): typeof Constants.__unsafeNoWarnManifest2 {
+  return Constants.__unsafeNoWarnManifest2;
+}
+
+export const manifestBaseUrl = Constants.experienceUrl
+  ? getManifestBaseUrl(Constants.experienceUrl)
+  : null;

package/src/core/ts-declarations/react-native-assets.d.ts

@@ -0,0 +1,75 @@
+// RN ships no types for these Flow-only internal modules; upstream expo-asset hand-writes the
+// same ambient declarations (src/ts-declarations/react-native-assets.d.ts, sdk-57).
+declare module 'react-native/Libraries/Image/AssetSourceResolver' {
+  import type { PackagerAsset } from '@react-native/assets-registry/registry';
+
+  export type ResolvedAssetSource = {
+    __packager_asset: boolean;
+    width?: number | null;
+    height?: number | null;
+    uri: string;
+    scale: number;
+  };
+
+  export default class AssetSourceResolver {
+    serverUrl: string | null;
+    jsbundleUrl: string | null;
+    asset: PackagerAsset & { fileHashes?: string[] };
+
+    constructor(
+      serverUrl: string | null,
+      jsbundleUrl: string | null,
+      asset: PackagerAsset,
+    );
+
+    isLoadedFromServer(): boolean;
+    isLoadedFromFileSystem(): boolean;
+    defaultAsset(): ResolvedAssetSource;
+    assetServerURL(): ResolvedAssetSource;
+    scaledAssetPath(): ResolvedAssetSource;
+    scaledAssetURLNearBundle(): ResolvedAssetSource;
+    resourceIdentifierWithoutScale(): ResolvedAssetSource;
+    drawableFolderInBundle(): ResolvedAssetSource;
+    fromSource(source: string): ResolvedAssetSource;
+
+    static pickScale(scales: number[], deviceScale: number): number;
+  }
+}
+
+declare module 'react-native/Libraries/Image/resolveAssetSource' {
+  import type AssetSourceResolver from 'react-native/Libraries/Image/AssetSourceResolver';
+  import type { ResolvedAssetSource } from 'react-native/Libraries/Image/AssetSourceResolver';
+
+  export type ICustomSourceTransformer = (
+    resolver: AssetSourceResolver,
+  ) => ResolvedAssetSource | null | undefined;
+
+  interface IResolveAssetSource {
+    (source: unknown): ResolvedAssetSource | null;
+    setCustomSourceTransformer?(transformer: ICustomSourceTransformer): void;
+  }
+
+  const resolveAssetSource: IResolveAssetSource;
+  export default resolveAssetSource;
+}
+
+declare module '@react-native/assets-registry/registry' {
+  export type PackagerAsset = {
+    readonly __packager_asset: boolean;
+    readonly fileSystemLocation: string;
+    readonly httpServerLocation: string;
+    readonly width?: number | null;
+    readonly height?: number | null;
+    readonly scales: number[];
+    readonly hash: string;
+    readonly name: string;
+    readonly type: string;
+  };
+
+  export function registerAsset(asset: PackagerAsset): number;
+  // Widened to match upstream's own override — Asset.fromModule's object branch always
+  // returns before reaching this call; the extra type only closes a narrowing gap tsc leaves.
+  export function getAssetByID(
+    assetId: number | { uri: string; width: number; height: number },
+  ): PackagerAsset | undefined;
+}

package/src/react/hooks/use-assets/index.ts

@@ -0,0 +1,19 @@
+// React lifecycle wiring over the framework-agnostic core (core/asset.ts). Loads once on mount;
+// upstream's own contract ("the assets are not reloaded when you dynamically change the asset
+// list") is preserved by the empty dependency array.
+import { useEffect, useState } from 'react';
+import { Asset } from '../../../core';
+
+export function useAssets(
+  moduleIds: number | number[],
+): [Asset[] | undefined, Error | undefined] {
+  const [assets, setAssets] = useState<Asset[]>();
+  const [error, setError] = useState<Error>();
+
+  useEffect(() => {
+    Asset.loadAsync(moduleIds).then(setAssets).catch(setError);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  return [assets, error];
+}

package/src/react/index.ts

@@ -0,0 +1,4 @@
+// @symbiote-native/asset/react: the React entry over the framework-agnostic core.
+
+export { useAssets } from './hooks/use-assets';
+export * from '../core';

package/src/solid/index.ts

@@ -0,0 +1,6 @@
+// @symbiote-native/asset/solid: the Solid entry over the framework-agnostic core — mirrors the
+// lifecycle-bucket naming convention of adapters/solid/src/primitives (never `hooks`/
+// `composables`/`runes`, those are React's, Vue's and Svelte's terms).
+
+export { createAssets } from './primitives/create-assets';
+export * from '../core';

package/src/solid/primitives/create-assets.ts

@@ -0,0 +1,16 @@
+// createAssets — the Solid twin of React's useAssets hook, over the framework-agnostic core
+// (core/asset.ts). Loads once from the primitive body, matching upstream's own contract.
+import { createSignal, type Accessor } from 'solid-js';
+import { Asset } from '../../core';
+
+export function createAssets(moduleIds: number | number[]): {
+  assets: Accessor<Asset[] | undefined>;
+  error: Accessor<Error | undefined>;
+} {
+  const [assets, setAssets] = createSignal<Asset[] | undefined>(undefined);
+  const [error, setError] = createSignal<Error | undefined>(undefined);
+
+  Asset.loadAsync(moduleIds).then(setAssets).catch(setError);
+
+  return { assets, error };
+}

package/src/svelte/index.ts

@@ -0,0 +1,6 @@
+// @symbiote-native/asset/svelte: the Svelte entry over the framework-agnostic core — mirrors the
+// lifecycle-bucket naming convention of adapters/svelte/src/runes (never `hooks`/`composables`,
+// those are React's and Vue's terms).
+
+export { useAssets } from './runes/use-assets.svelte';
+export * from '../core';

package/src/svelte/runes/use-assets.svelte.ts

@@ -0,0 +1,30 @@
+// Svelte lifecycle wiring over the framework-agnostic core (core/asset.ts). Loads once per
+// mount ($effect with no read of its own state), matching upstream's useAssets contract.
+import { Asset } from '../../core';
+
+export function useAssets(moduleIds: number | number[]): {
+  readonly assets: Asset[] | undefined;
+  readonly error: Error | undefined;
+} {
+  let assets = $state<Asset[] | undefined>(undefined);
+  let error = $state<Error | undefined>(undefined);
+
+  $effect(() => {
+    Asset.loadAsync(moduleIds)
+      .then(loaded => {
+        assets = loaded;
+      })
+      .catch((err: Error) => {
+        error = err;
+      });
+  });
+
+  return {
+    get assets(): Asset[] | undefined {
+      return assets;
+    },
+    get error(): Error | undefined {
+      return error;
+    },
+  };
+}

package/src/svelte/svelte-ambient.d.ts

@@ -0,0 +1,3 @@
+// Pulls in svelte's ambient global declarations ($state/$effect/...) for this package's tsc
+// program — see packages/network's identical file for the full rationale.
+/// <reference types="svelte" />

package/src/vue/composables/use-assets/index.ts

@@ -0,0 +1,30 @@
+// Vue lifecycle wiring over the framework-agnostic core (core/asset.ts). Loads once on mount,
+// matching upstream's own useAssets contract (a changed moduleIds prop is not reloaded).
+import {
+  onMounted,
+  ref,
+  shallowRef,
+  type Ref,
+  type ShallowRef,
+} from '@vue/runtime-core';
+import { Asset } from '../../../core';
+
+export function useAssets(moduleIds: number | number[]): {
+  assets: ShallowRef<Asset[] | undefined>;
+  error: Ref<Error | undefined>;
+} {
+  const assets = shallowRef<Asset[]>();
+  const error = ref<Error>();
+
+  onMounted(() => {
+    Asset.loadAsync(moduleIds)
+      .then(loaded => {
+        assets.value = loaded;
+      })
+      .catch((err: Error) => {
+        error.value = err;
+      });
+  });
+
+  return { assets, error };
+}

package/src/vue/index.ts

@@ -0,0 +1,4 @@
+// @symbiote-native/asset/vue: the Vue entry over the framework-agnostic core.
+
+export { useAssets } from './composables/use-assets';
+export * from '../core';