@vexor-push/react-native-code-push 0.2.0

package/android/src/oldarch/VexorCodePushSpec.kt

@@ -0,0 +1,24 @@
+package com.vexorpush.codepush
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.Promise
+
+abstract class VexorCodePushSpec internal constructor(context: ReactApplicationContext) :
+  ReactContextBaseJavaModule(context) {
+
+  abstract fun setupBundlePath(path: String?, extension: String?, version: Double?, maxVersions: Double?, metadata: String?, promise: Promise)
+  abstract fun downloadAndInstallBundle(url: String?, headersJson: String?, extension: String?, version: Double?, maxVersions: Double?, metadata: String?, promise: Promise)
+  abstract fun deleteBundle(i: Double, promise: Promise)
+  abstract fun restart()
+  abstract fun getCurrentVersion(a: Double, promise: Promise)
+  abstract fun setCurrentVersion(version: String?, promise: Promise)
+  abstract fun setExactBundlePath(path: String?, promise: Promise)
+  abstract fun rollbackToPreviousBundle(a: Double, promise: Promise)
+  abstract fun getUpdateMetadata(a: Double, promise: Promise)
+  abstract fun setUpdateMetadata(metadata: String?, promise: Promise)
+  abstract fun getBundleList(a: Double, promise: Promise)
+  abstract fun deleteBundleById(id: String, promise: Promise)
+  abstract fun clearAllBundles(a: Double, promise: Promise)
+  abstract fun writeFile(path: String?, base64Content: String?, encoding: String?, promise: Promise)
+}

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./plugin/build/index');

package/current-version.js

@@ -0,0 +1,27 @@
+function normalizeVersion(value) {
+  const version = Number(value);
+  return Number.isFinite(version) ? version : undefined;
+}
+
+function resolveCurrentVersion({ storedVersion, pendingVersion, nativeVersion } = {}) {
+  const normalizedStoredVersion = normalizeVersion(storedVersion);
+
+  if (Number.isFinite(normalizedStoredVersion)) {
+    return normalizedStoredVersion;
+  }
+
+  const normalizedPendingVersion = normalizeVersion(pendingVersion);
+
+  if (Number.isFinite(normalizedPendingVersion)) {
+    return normalizedPendingVersion;
+  }
+
+  const normalizedNativeVersion = normalizeVersion(nativeVersion);
+
+  return Number.isFinite(normalizedNativeVersion) ? normalizedNativeVersion : 0;
+}
+
+module.exports = {
+  normalizeVersion,
+  resolveCurrentVersion,
+};

package/deployment-state.js

@@ -0,0 +1,33 @@
+function normalizeDeployment(deployment) {
+  const value = String(deployment || "").trim().toLowerCase();
+  if (value === "development" || value === "staging") return value;
+  return "production";
+}
+
+function normalizePlatform(platform) {
+  const value = String(platform || "").trim().toLowerCase();
+  return value === "android" ? "android" : "ios";
+}
+
+function getDeploymentScope(config = {}) {
+  const deploymentKey = String(config.deploymentKey || "").trim();
+  if (deploymentKey) {
+    return `deployment-key:${deploymentKey}`;
+  }
+
+  const platform = normalizePlatform(config.platform);
+  const appName = String(config.appName || "").trim() || "*";
+  const deployment = normalizeDeployment(config.deployment);
+  return `deployment:${platform}:${appName}:${deployment}`;
+}
+
+function makeScopedKey(prefix, config = {}) {
+  return `${prefix}:${getDeploymentScope(config)}`;
+}
+
+module.exports = {
+  getDeploymentScope,
+  makeScopedKey,
+  normalizeDeployment,
+  normalizePlatform,
+};

package/index.d.ts

@@ -0,0 +1,101 @@
+import type { PlatformOSType } from "react-native";
+
+export type UpdateMode = "force" | "background" | "deferred" | "prompt";
+
+export type VexorOtaManifest = {
+  version: number;
+  downloadAndroidUrl?: string;
+  downloadIosUrl?: string;
+  download_url?: string;
+  label?: string;
+  is_mandatory?: boolean;
+  updateMode?: UpdateMode;
+  metadata?: Record<string, unknown> & {
+    mandatory?: boolean;
+    updateMode?: UpdateMode;
+    rollout?: number;
+    targetBinaryVersion?: string;
+    deploymentKey?: string;
+  };
+  [key: string]: unknown;
+};
+
+export type VexorOtaConfig = {
+  baseUrl?: string;
+  appName?: string;
+  deploymentKey?: string;
+  deployment?: string;
+  binaryVersion?: string;
+  platform?: PlatformOSType;
+  clientId?: string;
+  previousDeploymentKey?: string;
+  previousLabelOrAppVersion?: string;
+  downloadRetryAttempts?: number;
+  downloadRetryDelayMs?: number;
+  debug?: boolean;
+  storage?: {
+    getItem: (key: string) => string | null | Promise<string | null>;
+    setItem: (key: string, value: string) => void | Promise<void>;
+    removeItem: (key: string) => void | Promise<void>;
+  };
+  headers?: Record<string, string>;
+};
+
+export type CheckUpdateOptions = Partial<VexorOtaConfig> & {
+  currentVersion?: number;
+};
+
+export type VexorOtaUpdate = {
+  currentVersion: number;
+  hasUpdate: boolean;
+  manifest: VexorOtaManifest;
+  manifestUrl: string;
+  version: number;
+  downloadUrl?: string;
+  mandatory: boolean;
+  updateMode: UpdateMode;
+  metadata: Record<string, unknown>;
+};
+
+export type InstallUpdateOptions = Partial<VexorOtaConfig> & {
+  restartAfterInstall?: boolean;
+  restartDelay?: number;
+  extensionBundle?: string;
+  maxBundleVersions?: number;
+  rollbackOnFailedPending?: boolean;
+  restartAfterRollback?: boolean;
+  onSuccess?: () => void;
+  onError?: (error?: unknown) => void;
+  onProgress?: (received: string | number, total: string | number) => void;
+  onDownloadAttempt?: (info: {
+    attempt: number;
+    attempts: number;
+    downloadUrl: string;
+    version: number;
+  }) => void;
+};
+
+export function configure(config: VexorOtaConfig): VexorOtaConfig &
+  Required<Pick<VexorOtaConfig, "baseUrl" | "deployment" | "binaryVersion" | "platform">>;
+export function getConfig(): Partial<VexorOtaConfig>;
+export function getCurrentVersion(config?: Partial<VexorOtaConfig>): Promise<number>;
+export function getClientUniqueId(config?: Partial<VexorOtaConfig>): Promise<string>;
+export function checkUpdate(options?: CheckUpdateOptions): Promise<VexorOtaUpdate>;
+export function installUpdate(update: VexorOtaUpdate | VexorOtaManifest, options?: InstallUpdateOptions): Promise<void>;
+export function sync(options?: CheckUpdateOptions & InstallUpdateOptions): Promise<VexorOtaUpdate>;
+export function reset(restart?: boolean): void;
+export function notifyApplicationReady(options?: Partial<VexorOtaConfig>): Promise<{
+  status: "none" | "ready";
+  pending?: Record<string, unknown>;
+}>;
+export function checkPendingUpdate(options?: Partial<VexorOtaConfig> & {
+  rollbackOnFailedPending?: boolean;
+  restartAfterRollback?: boolean;
+}): Promise<{
+  status: "none" | "pending" | "rolledBack";
+  pending?: Record<string, unknown>;
+}>;
+export function reportDownload(payload: Record<string, unknown>, config?: Partial<VexorOtaConfig>): Promise<void>;
+export function reportDeploy(payload: Record<string, unknown>, config?: Partial<VexorOtaConfig>): Promise<void>;
+export function buildManifestUrl(config: VexorOtaConfig, currentVersion?: number): string;
+export function getDownloadUrl(manifest: VexorOtaManifest, platform?: PlatformOSType): string;