@symbiote-native/store-review 0.0.1

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,174 @@
+# @symbiote-native/store-review
+
+A wrapper package for [SymbioteNative](../../README.md) that makes
+[`expo-store-review`](https://github.com/expo/expo/tree/main/packages/expo-store-review)
+— prompting the platform's native in-app review flow — usable from **every** adapter, React,
+Vue, and Angular, not just React. Like [`@symbiote-native/device`](../device) and
+[`@symbiote-native/local-auth`](../local-auth), every export here is a one-shot async call with
+no per-instance state, so there is no hook/composable/service to wrap — the React, Vue, and
+Angular entry points are plain re-exports of the same `core`.
+
+## Install
+
+```bash
+npm install @symbiote-native/store-review
+```
+
+`expo-store-review` and `expo-modules-core` come along as regular dependencies, pinned to exact
+versions — never install either yourself, and never add the `expo` meta-package to your project
+(it bundles its own Metro/Babel pipeline, which conflicts with this project's own).
+
+## Required one-time step: native autolinking wiring
+
+Unlike a plain RN native module, `expo-store-review`'s native code is discovered by
+`expo-modules-autolinking`, not RN's own `react-native.config.cjs` mechanism — this needs wiring
+into the native host app **once**, covering this package and every other `expo-modules-core`
+package with zero further changes:
+
+| Platform | Touches |
+|---|---|
+| iOS | `ios/Podfile` — add `use_expo_modules!` |
+| iOS | `AppDelegate.swift` — Expo's runtime-bootstrap hook |
+| Android | `settings.gradle` / `app/build.gradle` — resolve and include the Expo Gradle projects |
+| Android | `MainApplication.kt` — Expo's bootstrap hook, plus a hand-written native-module name map (there's no `expo` meta-package here to auto-generate one) |
+
+Full mechanics live in the `symbiote-expo-native-module` project skill. Reference
+implementation: `examples/expo-react/ios/Podfile` and
+`examples/expo-react/android/app/src/main/java/com/canaryexpo/MainApplication.kt`.
+
+`expo-store-review` needs no runtime permission on either platform.
+
+## Shape
+
+```
+src/core/     isAvailableAsync / requestReview / hasAction, plus the IStoreReviewUrlOptions
+              type. native-module.ts resolves the native module via expo-modules-core's
+              requireNativeModule.
+src/react/    @symbiote-native/store-review/react   — export * from '../core'
+src/vue/      @symbiote-native/store-review/vue     — export * from '../core'
+src/angular/  @symbiote-native/store-review/angular — export * from '../core'
+```
+
+No per-adapter lifecycle wrapper exists because there's nothing to subscribe to or clean up —
+each adapter entry is a single-file re-export.
+
+## Use it
+
+```tsx
+// React
+import { Button } from '@symbiote-native/react';
+import { requestReview } from '@symbiote-native/store-review/react';
+
+function RateAppButton() {
+  return (
+    <Button
+      title="Rate this app"
+      onPress={() =>
+        requestReview({
+          iosAppStoreUrl: 'https://apps.apple.com/app/id123456789',
+          androidPlayStoreUrl: 'https://play.google.com/store/apps/details?id=com.example.app',
+        })
+      }
+    />
+  );
+}
+```
+
+```vue
+<!-- Vue -->
+<script setup lang="ts">
+import { Button } from '@symbiote-native/vue';
+import { requestReview } from '@symbiote-native/store-review/vue';
+
+function onRatePress() {
+  void requestReview({
+    iosAppStoreUrl: 'https://apps.apple.com/app/id123456789',
+    androidPlayStoreUrl: 'https://play.google.com/store/apps/details?id=com.example.app',
+  });
+}
+</script>
+
+<template>
+  <Button title="Rate this app" @press="onRatePress" />
+</template>
+```
+
+```ts
+// Angular
+import { Component } from '@angular/core';
+import { Button } from '@symbiote-native/angular';
+import { requestReview } from '@symbiote-native/store-review/angular';
+
+@Component({
+  standalone: true,
+  imports: [Button],
+  template: `<Button title="Rate this app" (press)="onRatePress()" />`,
+})
+export class RateAppButton {
+  onRatePress(): void {
+    void requestReview({
+      iosAppStoreUrl: 'https://apps.apple.com/app/id123456789',
+      androidPlayStoreUrl: 'https://play.google.com/store/apps/details?id=com.example.app',
+    });
+  }
+}
+```
+
+These snippets are not yet demoed in a real canary screen — treat them as realistic reference
+code, not a trimmed-down copy of a running demo.
+
+## API
+
+```ts
+export type IStoreReviewUrlOptions = {
+  iosAppStoreUrl?: string;
+  androidPlayStoreUrl?: string;
+};
+
+isAvailableAsync(): Promise<boolean>
+requestReview(options?: IStoreReviewUrlOptions): Promise<void>
+hasAction(options?: IStoreReviewUrlOptions): Promise<boolean>
+```
+
+```ts
+import { requestReview, isAvailableAsync, hasAction } from '@symbiote-native/store-review';
+// or the framework-scoped entry points — identical surface, re-exported verbatim:
+import { requestReview } from '@symbiote-native/store-review/react';
+import { requestReview } from '@symbiote-native/store-review/vue';
+import { requestReview } from '@symbiote-native/store-review/angular';
+```
+
+## Notes
+
+- **Deliberate deviation from upstream — no `expo-constants` dependency.** Upstream's
+  `storeUrl()` reads `Constants.expoConfig.ios.appStoreUrl`/`.android.playStoreUrl` off
+  `expo-constants`, which requires an Expo-CLI-generated manifest (`app.config`/EAS/updates)
+  this bare, Metro-only project never produces (see the `symbiote-expo-package-catalog` skill,
+  row 9 — `expo-constants` was skipped for exactly this reason). So this port trims that surface:
+  every function that would have read the manifest instead takes an optional
+  `IStoreReviewUrlOptions` argument (`iosAppStoreUrl` / `androidPlayStoreUrl`), and the caller
+  supplies the store URL explicitly instead of it being resolved from `app.json`/`app.config.js`.
+  There is no standalone `storeUrl()` export — its logic lives inline as a private helper,
+  since it now takes the same options argument every public function does.
+- **`requestReview()` prefers the native in-app review flow** (iOS `SKStoreReviewController`,
+  Android's Play Core in-app review API) and only falls back to opening the supplied store URL
+  via `Linking` when the native flow is unavailable — matching upstream's own fallback order.
+- **A missing URL on the fallback path logs a warning, never throws** — matching upstream's own
+  `console.warn`-and-continue behavior, just with different wording (pointing at the
+  `IStoreReviewUrlOptions` argument instead of `app.json`).
+
+## Test it
+
+No Fabric/Descriptor angle at all — every export here is a pure async-function surface, never a
+view or per-instance state. Tests inject a fake native-module object in place of the real
+`requireNativeModule` resolution, plus a stubbed `expo-modules-core` `Platform` and a stubbed
+`react-native` `Linking` (`src/core/store-review.test.ts`, `vitest`) — no `installFabric()`, no
+ViewConfig. Native rendering itself is verified on-device (see the parent
+[README](../../README.md) for the project's testing model).
+
+Native autolinking wiring for `expo-modules-core` packages is already done in the four Expo
+canary apps (`examples/expo-react`, `examples/expo-vue-sfc`, `examples/expo-vue-tsx`,
+`examples/expo-angular`) via `@symbiote-native/local-auth`/`@symbiote-native/sensors` — this
+package reuses that same wiring with zero further app-side changes, since
+`expo-modules-autolinking` discovers any `expo-modules-core` package already present in
+`node_modules`. A dedicated demo screen has not been wired into those canaries yet.

package/build/angular/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/angular/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/store-review/angular: the Angular entry over the framework-agnostic core.
+// Same reasoning as the React/Vue entries — no per-instance state or event stream to wrap in a
+// service, so this is a plain re-export.
+export * from '../core';

package/build/core/index.d.ts

@@ -0,0 +1,2 @@
+export { isAvailableAsync, requestReview, hasAction } from './store-review';
+export type { IStoreReviewUrlOptions } from './store-review';

package/build/core/index.js

@@ -0,0 +1 @@
+export { isAvailableAsync, requestReview, hasAction } from './store-review';

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

@@ -0,0 +1,5 @@
+export type INativeStoreReviewModule = {
+    isAvailableAsync?(): Promise<boolean>;
+    requestReview?(): Promise<void>;
+};
+export declare const expoStoreReview: INativeStoreReviewModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_STORE_REVIEW_MODULE_NAME = 'ExpoStoreReview';
+export const expoStoreReview = requireNativeModule(EXPO_STORE_REVIEW_MODULE_NAME);

package/build/core/store-review.d.ts

@@ -0,0 +1,30 @@
+export type IStoreReviewUrlOptions = {
+    iosAppStoreUrl?: string;
+    androidPlayStoreUrl?: string;
+};
+/**
+ * Determines if the platform has the capabilities to use `requestReview()`'s native flow.
+ * @return
+ * - On iOS, resolves to `true` unless the app is distributed through TestFlight.
+ * - On Android, resolves to `true` when the Play Store app is installed — upstream's own JSDoc
+ *   claims "Android 5.0+", but its `StoreReviewModule.kt` checks only for that package.
+ *
+ * A `true` from either platform still does not mean a prompt will appear.
+ */
+export declare function isAvailableAsync(): Promise<boolean>;
+/**
+ * In ideal circumstances this opens a native modal letting the user pick a star rating that's
+ * then applied to the App Store/Play Store, without leaving the app. If the native flow is
+ * unavailable, falls back to opening the store URL supplied via `options`.
+ *
+ * Resolving does NOT mean a prompt appeared — neither store reports that back, by design, so
+ * there is nothing to branch on. On Android it only shows for a build installed from Google
+ * Play; a sideloaded build runs the whole Play Core flow and displays nothing. Both stores also
+ * enforce a quota.
+ */
+export declare function requestReview(options?: IStoreReviewUrlOptions): Promise<void>;
+/**
+ * @return `true` if `requestReview()` is capable of directing the user to some kind of store
+ * review flow — either the native flow is available, or a store URL was supplied via `options`.
+ */
+export declare function hasAction(options?: IStoreReviewUrlOptions): Promise<boolean>;

package/build/core/store-review.js

@@ -0,0 +1,68 @@
+// Hand-ported from .vendors/expo/packages/expo-store-review/src/StoreReview.ts (sdk-57), with
+// one deliberate deviation: upstream's `storeUrl()` reads
+// `Constants.expoConfig.ios.appStoreUrl`/`.android.playStoreUrl` off `expo-constants`, which this
+// project doesn't depend on (symbiote-expo-package-catalog skill, row 9 — expo-constants hard-
+// depends on an Expo-CLI-generated manifest a bare/Metro-only project like this one never
+// produces). So the store URL is supplied explicitly by the caller instead of being read from a
+// manifest — every function below takes an optional `IStoreReviewUrlOptions` in place of
+// upstream's implicit `Constants` read.
+import { Platform } from 'expo-modules-core';
+import { Linking } from 'react-native';
+import { expoStoreReview } from './native-module';
+/**
+ * Determines if the platform has the capabilities to use `requestReview()`'s native flow.
+ * @return
+ * - On iOS, resolves to `true` unless the app is distributed through TestFlight.
+ * - On Android, resolves to `true` when the Play Store app is installed — upstream's own JSDoc
+ *   claims "Android 5.0+", but its `StoreReviewModule.kt` checks only for that package.
+ *
+ * A `true` from either platform still does not mean a prompt will appear.
+ */
+export async function isAvailableAsync() {
+    return expoStoreReview.isAvailableAsync?.() ?? false;
+}
+function urlFor(options) {
+    if (Platform.OS === 'ios') {
+        return options?.iosAppStoreUrl ?? null;
+    }
+    if (Platform.OS === 'android') {
+        return options?.androidPlayStoreUrl ?? null;
+    }
+    return null;
+}
+/**
+ * In ideal circumstances this opens a native modal letting the user pick a star rating that's
+ * then applied to the App Store/Play Store, without leaving the app. If the native flow is
+ * unavailable, falls back to opening the store URL supplied via `options`.
+ *
+ * Resolving does NOT mean a prompt appeared — neither store reports that back, by design, so
+ * there is nothing to branch on. On Android it only shows for a build installed from Google
+ * Play; a sideloaded build runs the whole Play Core flow and displays nothing. Both stores also
+ * enforce a quota.
+ */
+export async function requestReview(options) {
+    if (expoStoreReview.requestReview) {
+        return expoStoreReview.requestReview();
+    }
+    const url = urlFor(options);
+    if (url) {
+        const supported = await Linking.canOpenURL(url);
+        if (!supported) {
+            console.warn(`StoreReview.requestReview(): Can't open store url: ${url}`);
+        }
+        else {
+            await Linking.openURL(url);
+        }
+    }
+    else {
+        console.warn('StoreReview.requestReview(): no native review flow and no store URL was provided — ' +
+            'pass { iosAppStoreUrl, androidPlayStoreUrl } to requestReview().');
+    }
+}
+/**
+ * @return `true` if `requestReview()` is capable of directing the user to some kind of store
+ * review flow — either the native flow is available, or a store URL was supplied via `options`.
+ */
+export async function hasAction(options) {
+    return !!urlFor(options) || (await isAvailableAsync());
+}

package/build/react/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/react/index.js

@@ -0,0 +1,5 @@
+// @symbiote-native/store-review/react: the React entry over the framework-agnostic core.
+// Upstream ships free async functions, no per-instance state and no event stream — there is
+// nothing for a hook to wrap, so this is a plain re-export, mirroring
+// @symbiote-native/device's/@symbiote-native/local-auth's React entry.
+export * from '../core';

package/build/vue/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/vue/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/store-review/vue: the Vue entry over the framework-agnostic core. Same
+// reasoning as the React entry — no per-instance state or event stream to wire onto Vue's
+// reactivity, so this is a plain re-export.
+export * from '../core';

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

@@ -0,0 +1 @@
+export * from '../core';

package/build-ngc/angular/index.js

@@ -0,0 +1,5 @@
+// @symbiote-native/store-review/angular: the Angular entry over the framework-agnostic core.
+// Same reasoning as the React/Vue entries — no per-instance state or event stream to wrap in a
+// service, so this is a plain re-export.
+export * from '../core';
+//# 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,6FAA6F;AAC7F,+FAA+F;AAC/F,yCAAyC;AACzC,cAAc,SAAS,CAAC"}

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

@@ -0,0 +1,2 @@
+export { isAvailableAsync, requestReview, hasAction } from './store-review';
+export type { IStoreReviewUrlOptions } from './store-review';

package/build-ngc/core/index.js

@@ -0,0 +1,2 @@
+export { isAvailableAsync, requestReview, hasAction } from './store-review';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}

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

@@ -0,0 +1,5 @@
+export type INativeStoreReviewModule = {
+    isAvailableAsync?(): Promise<boolean>;
+    requestReview?(): Promise<void>;
+};
+export declare const expoStoreReview: INativeStoreReviewModule;

package/build-ngc/core/native-module.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_STORE_REVIEW_MODULE_NAME = 'ExpoStoreReview';
+export const expoStoreReview = requireNativeModule(EXPO_STORE_REVIEW_MODULE_NAME);
+//# sourceMappingURL=native-module.js.map

package/build-ngc/core/native-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-module.js","sourceRoot":"","sources":["../../src/core/native-module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,MAAM,6BAA6B,GAAG,iBAAiB,CAAC;AAWxD,MAAM,CAAC,MAAM,eAAe,GAAG,mBAAmB,CAChD,6BAA6B,CAC9B,CAAC"}

package/build-ngc/core/store-review.d.ts

@@ -0,0 +1,30 @@
+export type IStoreReviewUrlOptions = {
+    iosAppStoreUrl?: string;
+    androidPlayStoreUrl?: string;
+};
+/**
+ * Determines if the platform has the capabilities to use `requestReview()`'s native flow.
+ * @return
+ * - On iOS, resolves to `true` unless the app is distributed through TestFlight.
+ * - On Android, resolves to `true` when the Play Store app is installed — upstream's own JSDoc
+ *   claims "Android 5.0+", but its `StoreReviewModule.kt` checks only for that package.
+ *
+ * A `true` from either platform still does not mean a prompt will appear.
+ */
+export declare function isAvailableAsync(): Promise<boolean>;
+/**
+ * In ideal circumstances this opens a native modal letting the user pick a star rating that's
+ * then applied to the App Store/Play Store, without leaving the app. If the native flow is
+ * unavailable, falls back to opening the store URL supplied via `options`.
+ *
+ * Resolving does NOT mean a prompt appeared — neither store reports that back, by design, so
+ * there is nothing to branch on. On Android it only shows for a build installed from Google
+ * Play; a sideloaded build runs the whole Play Core flow and displays nothing. Both stores also
+ * enforce a quota.
+ */
+export declare function requestReview(options?: IStoreReviewUrlOptions): Promise<void>;
+/**
+ * @return `true` if `requestReview()` is capable of directing the user to some kind of store
+ * review flow — either the native flow is available, or a store URL was supplied via `options`.
+ */
+export declare function hasAction(options?: IStoreReviewUrlOptions): Promise<boolean>;

package/build-ngc/core/store-review.js

@@ -0,0 +1,69 @@
+// Hand-ported from .vendors/expo/packages/expo-store-review/src/StoreReview.ts (sdk-57), with
+// one deliberate deviation: upstream's `storeUrl()` reads
+// `Constants.expoConfig.ios.appStoreUrl`/`.android.playStoreUrl` off `expo-constants`, which this
+// project doesn't depend on (symbiote-expo-package-catalog skill, row 9 — expo-constants hard-
+// depends on an Expo-CLI-generated manifest a bare/Metro-only project like this one never
+// produces). So the store URL is supplied explicitly by the caller instead of being read from a
+// manifest — every function below takes an optional `IStoreReviewUrlOptions` in place of
+// upstream's implicit `Constants` read.
+import { Platform } from 'expo-modules-core';
+import { Linking } from 'react-native';
+import { expoStoreReview } from './native-module';
+/**
+ * Determines if the platform has the capabilities to use `requestReview()`'s native flow.
+ * @return
+ * - On iOS, resolves to `true` unless the app is distributed through TestFlight.
+ * - On Android, resolves to `true` when the Play Store app is installed — upstream's own JSDoc
+ *   claims "Android 5.0+", but its `StoreReviewModule.kt` checks only for that package.
+ *
+ * A `true` from either platform still does not mean a prompt will appear.
+ */
+export async function isAvailableAsync() {
+    return expoStoreReview.isAvailableAsync?.() ?? false;
+}
+function urlFor(options) {
+    if (Platform.OS === 'ios') {
+        return options?.iosAppStoreUrl ?? null;
+    }
+    if (Platform.OS === 'android') {
+        return options?.androidPlayStoreUrl ?? null;
+    }
+    return null;
+}
+/**
+ * In ideal circumstances this opens a native modal letting the user pick a star rating that's
+ * then applied to the App Store/Play Store, without leaving the app. If the native flow is
+ * unavailable, falls back to opening the store URL supplied via `options`.
+ *
+ * Resolving does NOT mean a prompt appeared — neither store reports that back, by design, so
+ * there is nothing to branch on. On Android it only shows for a build installed from Google
+ * Play; a sideloaded build runs the whole Play Core flow and displays nothing. Both stores also
+ * enforce a quota.
+ */
+export async function requestReview(options) {
+    if (expoStoreReview.requestReview) {
+        return expoStoreReview.requestReview();
+    }
+    const url = urlFor(options);
+    if (url) {
+        const supported = await Linking.canOpenURL(url);
+        if (!supported) {
+            console.warn(`StoreReview.requestReview(): Can't open store url: ${url}`);
+        }
+        else {
+            await Linking.openURL(url);
+        }
+    }
+    else {
+        console.warn('StoreReview.requestReview(): no native review flow and no store URL was provided — ' +
+            'pass { iosAppStoreUrl, androidPlayStoreUrl } to requestReview().');
+    }
+}
+/**
+ * @return `true` if `requestReview()` is capable of directing the user to some kind of store
+ * review flow — either the native flow is available, or a store URL was supplied via `options`.
+ */
+export async function hasAction(options) {
+    return !!urlFor(options) || (await isAvailableAsync());
+}
+//# sourceMappingURL=store-review.js.map

package/build-ngc/core/store-review.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-review.js","sourceRoot":"","sources":["../../src/core/store-review.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,0DAA0D;AAC1D,kGAAkG;AAClG,+FAA+F;AAC/F,0FAA0F;AAC1F,gGAAgG;AAChG,yFAAyF;AACzF,wCAAwC;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAOlD;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB;IACpC,OAAO,eAAe,CAAC,gBAAgB,EAAE,EAAE,IAAI,KAAK,CAAC;AACvD,CAAC;AAED,SAAS,MAAM,CAAC,OAAgC;IAC9C,IAAI,QAAQ,CAAC,EAAE,KAAK,KAAK,EAAE,CAAC;QAC1B,OAAO,OAAO,EAAE,cAAc,IAAI,IAAI,CAAC;IACzC,CAAC;IACD,IAAI,QAAQ,CAAC,EAAE,KAAK,SAAS,EAAE,CAAC;QAC9B,OAAO,OAAO,EAAE,mBAAmB,IAAI,IAAI,CAAC;IAC9C,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,OAAgC;IAClE,IAAI,eAAe,CAAC,aAAa,EAAE,CAAC;QAClC,OAAO,eAAe,CAAC,aAAa,EAAE,CAAC;IACzC,CAAC;IACD,MAAM,GAAG,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;IAC5B,IAAI,GAAG,EAAE,CAAC;QACR,MAAM,SAAS,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;QAChD,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,OAAO,CAAC,IAAI,CAAC,sDAAsD,GAAG,EAAE,CAAC,CAAC;QAC5E,CAAC;aAAM,CAAC;YACN,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;SAAM,CAAC;QACN,OAAO,CAAC,IAAI,CACV,qFAAqF;YACnF,kEAAkE,CACrE,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,OAAgC;IAC9D,OAAO,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,gBAAgB,EAAE,CAAC,CAAC;AACzD,CAAC"}

package/native-link.json

@@ -0,0 +1,12 @@
+{
+  "android": {
+    "gradleProjectName": "expo-store-review",
+    "modules": [
+      {
+        "importPath": "expo.modules.storereview.StoreReviewModule",
+        "className": "StoreReviewModule",
+        "nativeName": "ExpoStoreReview"
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@symbiote-native/store-review",
+  "version": "0.0.1",
+  "description": "expo-store-review wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, and Angular adapters. Prompts the platform's native in-app review flow, with a caller-supplied store-URL fallback in place of upstream's expo-constants-based lookup (this project doesn't depend on expo-constants).",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneEyed1366/symbiote-native.git",
+    "directory": "packages/store-review"
+  },
+  "homepage": "https://github.com/OneEyed1366/symbiote-native/tree/master/packages/store-review#readme",
+  "bugs": {
+    "url": "https://github.com/OneEyed1366/symbiote-native/issues"
+  },
+  "author": "Andrey Prokopenko <psevdoproger@gmail.com>",
+  "type": "module",
+  "main": "./build/core/index.js",
+  "module": "./build/core/index.js",
+  "types": "./build/core/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/core/index.d.ts",
+      "default": "./build/core/index.js"
+    },
+    "./vue": {
+      "types": "./build/vue/index.d.ts",
+      "default": "./build/vue/index.js"
+    },
+    "./react": {
+      "types": "./build/react/index.d.ts",
+      "default": "./build/react/index.js"
+    },
+    "./angular": {
+      "types": "./build-ngc/angular/index.d.ts",
+      "react-native": "./build-ngc/angular/index.js",
+      "default": "./src/angular/index.ts"
+    }
+  },
+  "files": [
+    "src",
+    "build",
+    "build-ngc",
+    "native-link.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "expo-store-review": "57.0.1",
+    "expo-modules-core": "57.0.5"
+  },
+  "peerDependencies": {
+    "@symbiote-native/engine": ">=0.1.7",
+    "@angular/core": ">=20",
+    "@vue/runtime-core": "^3.5.13",
+    "react": ">=19.0.0",
+    "react-native": ">=0.86",
+    "vue": ">=3.5.0",
+    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/angular": "0.6.1",
+    "@symbiote-native/vue": "0.3.8"
+  },
+  "peerDependenciesMeta": {
+    "@symbiote-native/angular": {
+      "optional": true
+    },
+    "@symbiote-native/react": {
+      "optional": true
+    },
+    "@symbiote-native/vue": {
+      "optional": true
+    },
+    "@angular/core": {
+      "optional": true
+    },
+    "@vue/runtime-core": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@angular/compiler": "^22",
+    "@angular/compiler-cli": "^22",
+    "@angular/core": "^22",
+    "@types/node": "^26.0.0",
+    "@types/react": "^19.2.0",
+    "@vue/runtime-core": "^3.5.13",
+    "react": "19.2.3",
+    "typescript": "~6.0.0",
+    "@symbiote-native/angular": "0.6.1",
+    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/vue": "0.3.8",
+    "@symbiote-native/test-utils": "0.1.6",
+    "@symbiote-native/engine": "0.1.7"
+  },
+  "scripts": {
+    "typecheck": "tsc --build",
+    "clean": "rm -rf build-ngc",
+    "ng:build": "pnpm run clean && ngc -p tsconfig.angular.json",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\""
+  }
+}

package/src/angular/index.ts

@@ -0,0 +1,4 @@
+// @symbiote-native/store-review/angular: the Angular entry over the framework-agnostic core.
+// Same reasoning as the React/Vue entries — no per-instance state or event stream to wrap in a
+// service, so this is a plain re-export.
+export * from '../core';

package/src/core/index.ts

@@ -0,0 +1,2 @@
+export { isAvailableAsync, requestReview, hasAction } from './store-review';
+export type { IStoreReviewUrlOptions } from './store-review';

package/src/core/native-module.ts

@@ -0,0 +1,16 @@
+import { requireNativeModule } from 'expo-modules-core';
+
+const EXPO_STORE_REVIEW_MODULE_NAME = 'ExpoStoreReview';
+
+// Both methods are optional for the same reason every sibling package's native module type is
+// (device, local-auth, cellular): the native review flow itself is platform-conditional
+// (iOS TestFlight builds, Android below 5.0), so store-review.ts checks for presence itself and
+// falls back to a store-URL open rather than assuming the whole surface is implemented.
+export type INativeStoreReviewModule = {
+  isAvailableAsync?(): Promise<boolean>;
+  requestReview?(): Promise<void>;
+};
+
+export const expoStoreReview = requireNativeModule<INativeStoreReviewModule>(
+  EXPO_STORE_REVIEW_MODULE_NAME,
+);

package/src/core/store-review.test.ts

@@ -0,0 +1,150 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const FAKE_NATIVE_STORE_REVIEW = {
+  isAvailableAsync: vi.fn(async () => true),
+  requestReview: vi.fn(async () => undefined),
+};
+
+const fakePlatform = { OS: 'ios' as 'ios' | 'android' | 'web' };
+
+const fakeLinking = {
+  canOpenURL: vi.fn(async () => true),
+  openURL: vi.fn(async () => undefined),
+};
+
+// The real ExpoStoreReview native module only exists on device — resolving it via
+// requireNativeModule() at import time would throw in this headless test run, so the
+// module-lookup file is faked in place of expo-modules-core's runtime resolution, the same
+// pattern packages/device/src/core/device.test.ts uses.
+vi.mock('./native-module', () => ({
+  expoStoreReview: FAKE_NATIVE_STORE_REVIEW,
+}));
+
+// expo-modules-core's real entry transitively imports 'react-native' for Platform/
+// TurboModuleRegistry, whose Flow-typed source Vitest's Oxc transform can't parse — same fake
+// packages/application/src/core/application.test.ts uses.
+vi.mock('expo-modules-core', () => ({
+  Platform: fakePlatform,
+}));
+
+// react-native's own Linking is only reached by the URL-fallback branch (no native review flow
+// available) — stubbed the same way packages/system-ui/src/core/system-ui.test.ts stubs
+// react-native's Platform/processColor.
+vi.mock('react-native', () => ({
+  Linking: fakeLinking,
+}));
+
+const { isAvailableAsync, requestReview, hasAction } = await import('./store-review');
+
+afterEach(() => {
+  fakePlatform.OS = 'ios';
+  FAKE_NATIVE_STORE_REVIEW.isAvailableAsync = vi.fn(async () => true);
+  FAKE_NATIVE_STORE_REVIEW.requestReview = vi.fn(async () => undefined);
+  vi.clearAllMocks();
+});
+
+describe('isAvailableAsync', () => {
+  it('delegates to the native module', async () => {
+    await expect(isAvailableAsync()).resolves.toBe(true);
+  });
+
+  it('resolves false instead of throwing when the native method is absent', async () => {
+    // @ts-expect-error -- simulating a platform where the native module has no such method
+    FAKE_NATIVE_STORE_REVIEW.isAvailableAsync = undefined;
+
+    await expect(isAvailableAsync()).resolves.toBe(false);
+  });
+});
+
+describe('requestReview — native review path', () => {
+  it('calls the native requestReview and never touches Linking', async () => {
+    await requestReview({ iosAppStoreUrl: 'https://apps.apple.com/app/id123' });
+
+    expect(FAKE_NATIVE_STORE_REVIEW.requestReview).toHaveBeenCalled();
+    expect(fakeLinking.canOpenURL).not.toHaveBeenCalled();
+    expect(fakeLinking.openURL).not.toHaveBeenCalled();
+  });
+});
+
+describe('requestReview — URL-fallback path (no native review flow)', () => {
+  it('opens the supplied iOS App Store URL when Linking can open it', async () => {
+    // @ts-expect-error -- simulating a platform with no native review flow
+    FAKE_NATIVE_STORE_REVIEW.requestReview = undefined;
+
+    await requestReview({ iosAppStoreUrl: 'https://apps.apple.com/app/id123' });
+
+    expect(fakeLinking.canOpenURL).toHaveBeenCalledWith('https://apps.apple.com/app/id123');
+    expect(fakeLinking.openURL).toHaveBeenCalledWith('https://apps.apple.com/app/id123');
+  });
+
+  it('opens the supplied Android Play Store URL on android', async () => {
+    // @ts-expect-error -- simulating a platform with no native review flow
+    FAKE_NATIVE_STORE_REVIEW.requestReview = undefined;
+    fakePlatform.OS = 'android';
+
+    await requestReview({
+      androidPlayStoreUrl: 'https://play.google.com/store/apps/details?id=com.app',
+    });
+
+    expect(fakeLinking.canOpenURL).toHaveBeenCalledWith(
+      'https://play.google.com/store/apps/details?id=com.app',
+    );
+    expect(fakeLinking.openURL).toHaveBeenCalledWith(
+      'https://play.google.com/store/apps/details?id=com.app',
+    );
+  });
+
+  it('warns and skips openURL when Linking reports the URL cannot be opened', async () => {
+    // @ts-expect-error -- simulating a platform with no native review flow
+    FAKE_NATIVE_STORE_REVIEW.requestReview = undefined;
+    fakeLinking.canOpenURL.mockResolvedValueOnce(false);
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+
+    await requestReview({ iosAppStoreUrl: 'https://apps.apple.com/app/id123' });
+
+    expect(fakeLinking.openURL).not.toHaveBeenCalled();
+    expect(warnSpy).toHaveBeenCalledWith(
+      "StoreReview.requestReview(): Can't open store url: https://apps.apple.com/app/id123",
+    );
+
+    warnSpy.mockRestore();
+  });
+
+  it('warns and never touches Linking when no URL was provided', async () => {
+    // @ts-expect-error -- simulating a platform with no native review flow
+    FAKE_NATIVE_STORE_REVIEW.requestReview = undefined;
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+
+    await requestReview();
+
+    expect(fakeLinking.canOpenURL).not.toHaveBeenCalled();
+    expect(fakeLinking.openURL).not.toHaveBeenCalled();
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('no native review flow and no store URL was provided'),
+    );
+
+    warnSpy.mockRestore();
+  });
+});
+
+describe('hasAction', () => {
+  it('resolves true when a store URL was supplied, without checking native availability', async () => {
+    // @ts-expect-error -- simulating a platform with no native review flow
+    FAKE_NATIVE_STORE_REVIEW.isAvailableAsync = undefined;
+
+    await expect(hasAction({ iosAppStoreUrl: 'https://apps.apple.com/app/id123' })).resolves.toBe(
+      true,
+    );
+  });
+
+  it('falls back to native availability when no store URL was supplied', async () => {
+    await expect(hasAction()).resolves.toBe(true);
+  });
+
+  it('resolves false when there is neither a store URL nor a native review flow', async () => {
+    // @ts-expect-error -- simulating a platform with no native review flow
+    FAKE_NATIVE_STORE_REVIEW.isAvailableAsync = undefined;
+
+    await expect(hasAction()).resolves.toBe(false);
+  });
+});

package/src/core/store-review.ts

@@ -0,0 +1,78 @@
+// Hand-ported from .vendors/expo/packages/expo-store-review/src/StoreReview.ts (sdk-57), with
+// one deliberate deviation: upstream's `storeUrl()` reads
+// `Constants.expoConfig.ios.appStoreUrl`/`.android.playStoreUrl` off `expo-constants`, which this
+// project doesn't depend on (symbiote-expo-package-catalog skill, row 9 — expo-constants hard-
+// depends on an Expo-CLI-generated manifest a bare/Metro-only project like this one never
+// produces). So the store URL is supplied explicitly by the caller instead of being read from a
+// manifest — every function below takes an optional `IStoreReviewUrlOptions` in place of
+// upstream's implicit `Constants` read.
+import { Platform } from 'expo-modules-core';
+import { Linking } from 'react-native';
+
+import { expoStoreReview } from './native-module';
+
+export type IStoreReviewUrlOptions = {
+  iosAppStoreUrl?: string;
+  androidPlayStoreUrl?: string;
+};
+
+/**
+ * Determines if the platform has the capabilities to use `requestReview()`'s native flow.
+ * @return
+ * - On iOS, resolves to `true` unless the app is distributed through TestFlight.
+ * - On Android, resolves to `true` when the Play Store app is installed — upstream's own JSDoc
+ *   claims "Android 5.0+", but its `StoreReviewModule.kt` checks only for that package.
+ *
+ * A `true` from either platform still does not mean a prompt will appear.
+ */
+export async function isAvailableAsync(): Promise<boolean> {
+  return expoStoreReview.isAvailableAsync?.() ?? false;
+}
+
+function urlFor(options?: IStoreReviewUrlOptions): string | null {
+  if (Platform.OS === 'ios') {
+    return options?.iosAppStoreUrl ?? null;
+  }
+  if (Platform.OS === 'android') {
+    return options?.androidPlayStoreUrl ?? null;
+  }
+  return null;
+}
+
+/**
+ * In ideal circumstances this opens a native modal letting the user pick a star rating that's
+ * then applied to the App Store/Play Store, without leaving the app. If the native flow is
+ * unavailable, falls back to opening the store URL supplied via `options`.
+ *
+ * Resolving does NOT mean a prompt appeared — neither store reports that back, by design, so
+ * there is nothing to branch on. On Android it only shows for a build installed from Google
+ * Play; a sideloaded build runs the whole Play Core flow and displays nothing. Both stores also
+ * enforce a quota.
+ */
+export async function requestReview(options?: IStoreReviewUrlOptions): Promise<void> {
+  if (expoStoreReview.requestReview) {
+    return expoStoreReview.requestReview();
+  }
+  const url = urlFor(options);
+  if (url) {
+    const supported = await Linking.canOpenURL(url);
+    if (!supported) {
+      console.warn(`StoreReview.requestReview(): Can't open store url: ${url}`);
+    } else {
+      await Linking.openURL(url);
+    }
+  } else {
+    console.warn(
+      'StoreReview.requestReview(): no native review flow and no store URL was provided — ' +
+        'pass { iosAppStoreUrl, androidPlayStoreUrl } to requestReview().',
+    );
+  }
+}
+
+/**
+ * @return `true` if `requestReview()` is capable of directing the user to some kind of store
+ * review flow — either the native flow is available, or a store URL was supplied via `options`.
+ */
+export async function hasAction(options?: IStoreReviewUrlOptions): Promise<boolean> {
+  return !!urlFor(options) || (await isAvailableAsync());
+}

package/src/react/index.ts

@@ -0,0 +1,5 @@
+// @symbiote-native/store-review/react: the React entry over the framework-agnostic core.
+// Upstream ships free async functions, no per-instance state and no event stream — there is
+// nothing for a hook to wrap, so this is a plain re-export, mirroring
+// @symbiote-native/device's/@symbiote-native/local-auth's React entry.
+export * from '../core';

package/src/vue/index.ts

@@ -0,0 +1,4 @@
+// @symbiote-native/store-review/vue: the Vue entry over the framework-agnostic core. Same
+// reasoning as the React entry — no per-instance state or event stream to wire onto Vue's
+// reactivity, so this is a plain re-export.
+export * from '../core';