vkdeploy-push 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-present 650 Industries, Inc. (aka Expo)
+
+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,98 @@
+# vkdeploy-push
+
+Biblioteca React Native para versionamento e atualizacao remota de bundle Android.
+
+## Escopo atual
+
+- Consulta versao remota do bundle.
+- Faz download do zip do bundle.
+- Extrai e substitui `index.android.bundle`.
+- Move assets Android `drawable-*`.
+- Persiste a versao local aplicada.
+
+Implementacao atual focada em Android.
+
+## Instalacao
+
+```bash
+npm install vkdeploy-push
+```
+
+O pacote instala automaticamente as dependencias usadas para filesystem, device info e unzip.
+
+## Uso
+
+Import nomeado:
+
+```ts
+import { getVersao, checkUpdate } from 'vkdeploy-push';
+```
+
+Import default:
+
+```ts
+import vkdeployPush from 'vkdeploy-push';
+
+await vkdeployPush.getVersao();
+```
+
+Exemplo de update:
+
+```ts
+const result = await checkUpdate();
+
+if (result.status === 'updated' && result.restartRequired) {
+  // O app decide como avisar o usuário e quando reiniciar.
+}
+
+if (result.status === 'error') {
+  console.log(result.error.code, result.error.message);
+}
+```
+
+## Configuracao
+
+Crie o arquivo `android/app/src/main/assets/versionamento-vktech-config.json`:
+
+```json
+{
+  "app_secret": "SEU_PROJETO_ID"
+}
+```
+
+## API
+
+### `getVersao()`
+
+Retorna a versao local salva no dispositivo.
+
+### `checkUpdate(antes?, depois?)`
+
+Consulta a versao remota e aplica update ou rollback quando houver diferenca.
+
+Retorno:
+
+- `status: 'up-to-date'` quando nao ha mudanca.
+- `status: 'updated'` quando aplicou update ou rollback.
+- `status: 'error'` quando houve falha tipada, com `error.code` estavel.
+
+### `atualizar(versao, projetoId, antes?, depois?)`
+
+Baixa, extrai e aplica manualmente uma versao especifica do bundle.
+
+Quando o update e aplicado com sucesso, a biblioteca retorna `restartRequired: true`.
+Ela nao exibe `Alert` nem reinicia o app automaticamente.
+
+## Logger
+
+Voce pode injetar um logger proprio:
+
+```ts
+import { setLogger } from 'vkdeploy-push';
+
+setLogger({
+  info: (message, context) => console.log(message, context),
+  warn: (message, context) => console.warn(message, context),
+  error: (message, context) => console.error(message, context),
+});
+```

package/dist/bundle.d.ts

@@ -0,0 +1,8 @@
+import type { RNFSModule } from './runtime';
+import type { VkDeployError } from './types';
+export declare function ensureTempDirectory(rnfs: RNFSModule, tempPath: string): Promise<VkDeployError | undefined>;
+export declare function cleanupTempDirectory(rnfs: RNFSModule, tempPath: string): Promise<VkDeployError | undefined>;
+export declare function removeFileIfExists(rnfs: RNFSModule, path: string): Promise<VkDeployError | undefined>;
+export declare function unzipBundleArchive(rnfs: RNFSModule, unzipFile: (source: string, target: string) => Promise<unknown>, arquivo: string, destino: string): Promise<VkDeployError | undefined>;
+export declare function moveExtractedAssets(rnfs: RNFSModule, tempRoot: string, finalRoot: string): Promise<VkDeployError | undefined>;
+export declare function moveExtractedBundle(rnfs: RNFSModule, origem: string, destino: string): Promise<VkDeployError | undefined>;

package/dist/bundle.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureTempDirectory = ensureTempDirectory;
+exports.cleanupTempDirectory = cleanupTempDirectory;
+exports.removeFileIfExists = removeFileIfExists;
+exports.unzipBundleArchive = unzipBundleArchive;
+exports.moveExtractedAssets = moveExtractedAssets;
+exports.moveExtractedBundle = moveExtractedBundle;
+const logger_1 = require("./logger");
+const DRAWABLE_DENSITIES = ['mdpi', 'hdpi', 'xhdpi', 'xxhdpi', 'xxxhdpi'];
+async function ensureDirectory(rnfs, path) {
+    try {
+        if (!(await rnfs.exists(path))) {
+            await rnfs.mkdir(path);
+        }
+        return undefined;
+    }
+    catch (cause) {
+        return (0, logger_1.createError)('FILESYSTEM_ERROR', `Falha ao criar diretório: ${path}`, cause);
+    }
+}
+async function removePathIfExists(rnfs, path) {
+    try {
+        if (await rnfs.exists(path)) {
+            await rnfs.unlink(path);
+        }
+        return undefined;
+    }
+    catch (cause) {
+        return (0, logger_1.createError)('FILESYSTEM_ERROR', `Falha ao remover caminho temporário: ${path}`, cause);
+    }
+}
+async function moveDirectoryContents(rnfs, origem, destino) {
+    try {
+        const origemExiste = await rnfs.exists(origem);
+        if (!origemExiste) {
+            return undefined;
+        }
+        const origemInfo = await rnfs.stat(origem);
+        if (!origemInfo.isDirectory()) {
+            return (0, logger_1.createError)('FILESYSTEM_ERROR', `O caminho de origem não é uma pasta: ${origem}`);
+        }
+        const ensureDestinoError = await ensureDirectory(rnfs, destino);
+        if (ensureDestinoError) {
+            return ensureDestinoError;
+        }
+        const itens = await rnfs.readDir(origem);
+        for (const item of itens) {
+            const caminhoOrigem = item.path;
+            const caminhoDestino = `${destino}/${item.name}`;
+            if (item.isDirectory()) {
+                const moveError = await moveDirectoryContents(rnfs, caminhoOrigem, caminhoDestino);
+                if (moveError) {
+                    return moveError;
+                }
+                continue;
+            }
+            if (item.isFile()) {
+                await rnfs.moveFile(caminhoOrigem, caminhoDestino);
+            }
+        }
+        await rnfs.unlink(origem);
+        return undefined;
+    }
+    catch (cause) {
+        return (0, logger_1.createError)('FILESYSTEM_ERROR', `Erro ao mover pasta de ${origem} para ${destino}.`, cause);
+    }
+}
+async function ensureTempDirectory(rnfs, tempPath) {
+    return ensureDirectory(rnfs, tempPath);
+}
+async function cleanupTempDirectory(rnfs, tempPath) {
+    return removePathIfExists(rnfs, tempPath);
+}
+async function removeFileIfExists(rnfs, path) {
+    return removePathIfExists(rnfs, path);
+}
+async function unzipBundleArchive(rnfs, unzipFile, arquivo, destino) {
+    try {
+        if (!(await rnfs.exists(arquivo))) {
+            return (0, logger_1.createError)('UNZIP_FAILED', `Arquivo ZIP não encontrado: ${arquivo}`);
+        }
+        await unzipFile(arquivo, destino);
+        const cleanupError = await removeFileIfExists(rnfs, arquivo);
+        if (cleanupError) {
+            return cleanupError;
+        }
+        return undefined;
+    }
+    catch (cause) {
+        return (0, logger_1.createError)('UNZIP_FAILED', 'Erro ao descompactar o bundle.', cause);
+    }
+}
+async function moveExtractedAssets(rnfs, tempRoot, finalRoot) {
+    for (const density of DRAWABLE_DENSITIES) {
+        const origem = `${tempRoot}/drawable-${density}`;
+        const destino = `${finalRoot}/drawable-${density}`;
+        const error = await moveDirectoryContents(rnfs, origem, destino);
+        if (error) {
+            return error;
+        }
+    }
+    return undefined;
+}
+async function moveExtractedBundle(rnfs, origem, destino) {
+    try {
+        if (!(await rnfs.exists(origem))) {
+            return (0, logger_1.createError)('FILESYSTEM_ERROR', `Bundle extraído não encontrado: ${origem}`);
+        }
+        await rnfs.moveFile(origem, destino);
+        return undefined;
+    }
+    catch (cause) {
+        return (0, logger_1.createError)('FILESYSTEM_ERROR', 'Erro ao mover o bundle atualizado.', cause);
+    }
+}

package/dist/database/DBSQL.d.ts

@@ -0,0 +1,3 @@
+import type { VersaoInfo } from '../types';
+export declare function salvarVersao(versao: number): Promise<void>;
+export declare function buscaVersao(): Promise<VersaoInfo>;

package/dist/database/DBSQL.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.salvarVersao = salvarVersao;
+exports.buscaVersao = buscaVersao;
+const runtime_1 = require("../runtime");
+function getVersionPath(documentDirectoryPath) {
+    return `${documentDirectoryPath}/db.json`;
+}
+async function salvarVersao(versao) {
+    const rnfs = await (0, runtime_1.loadRNFS)();
+    if (!rnfs.ok) {
+        return;
+    }
+    try {
+        await rnfs.module.writeFile(getVersionPath(rnfs.module.DocumentDirectoryPath), JSON.stringify({ versao }), 'utf8');
+    }
+    catch (error) {
+        console.log(error);
+    }
+}
+async function buscaVersao() {
+    var _a;
+    const bundle = await (0, runtime_1.getSafeBundleVersion)();
+    const rnfs = await (0, runtime_1.loadRNFS)();
+    if (!rnfs.ok) {
+        return (0, runtime_1.buildVersionInfo)(bundle, 0);
+    }
+    try {
+        const versionPath = getVersionPath(rnfs.module.DocumentDirectoryPath);
+        const exists = await rnfs.module.exists(versionPath);
+        if (!exists) {
+            return (0, runtime_1.buildVersionInfo)(bundle, 0);
+        }
+        const fileContent = await rnfs.module.readFile(versionPath, 'utf8');
+        const jsonData = JSON.parse(fileContent);
+        return (0, runtime_1.buildVersionInfo)(bundle, (_a = jsonData.versao) !== null && _a !== void 0 ? _a : 0);
+    }
+    catch (error) {
+        console.log(error);
+        return (0, runtime_1.buildVersionInfo)(bundle, 0);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import { setLogger, resetLogger } from './logger';
+import type { AtualizarResult, CheckUpdateResult, UpdateLifecycleCallback, VersaoInfo } from './types';
+export declare function getVersao(): Promise<VersaoInfo>;
+export declare function checkUpdate(antes?: UpdateLifecycleCallback, depois?: UpdateLifecycleCallback): Promise<CheckUpdateResult>;
+export declare function atualizar(versao: number, projetoId: string, antes?: UpdateLifecycleCallback, depois?: UpdateLifecycleCallback): Promise<AtualizarResult>;
+declare const vkdeployPush: {
+    getVersao: typeof getVersao;
+    checkUpdate: typeof checkUpdate;
+    atualizar: typeof atualizar;
+    setLogger: typeof setLogger;
+    resetLogger: typeof resetLogger;
+};
+export default vkdeployPush;
+export type { AtualizarResult, CheckUpdateResult, ErrorCheckResult, ErrorUpdateResult, LoggerContext, RemoteVersionResponse, UpdateLifecycleCallback, UpdatedCheckResult, UpdatedResult, UpToDateCheckResult, VersaoInfo, VkDeployError, VkDeployErrorCode, VkDeployLogger, } from './types';
+export { resetLogger, setLogger };

package/dist/index.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setLogger = exports.resetLogger = void 0;
+exports.getVersao = getVersao;
+exports.checkUpdate = checkUpdate;
+exports.atualizar = atualizar;
+const bundle_1 = require("./bundle");
+const DBSQL_1 = require("./database/DBSQL");
+const logger_1 = require("./logger");
+Object.defineProperty(exports, "setLogger", { enumerable: true, get: function () { return logger_1.setLogger; } });
+Object.defineProperty(exports, "resetLogger", { enumerable: true, get: function () { return logger_1.resetLogger; } });
+const network_1 = require("./network");
+const runtime_1 = require("./runtime");
+const functions_1 = require("./utils/functions");
+const API_BASE_URL = 'https://versionamento-back-end-388770734965.us-central1.run.app';
+function toCheckErrorResult(error, version) {
+    (0, logger_1.logError)(error.message, {
+        code: error.code,
+        cause: error.cause,
+    });
+    return {
+        status: 'error',
+        error,
+        version,
+    };
+}
+function toUpdateErrorResult(error) {
+    (0, logger_1.logError)(error.message, {
+        code: error.code,
+        cause: error.cause,
+    });
+    return {
+        status: 'error',
+        error,
+    };
+}
+async function runCallback(callback) {
+    if (typeof callback === 'function') {
+        await callback();
+    }
+}
+async function loadUpdateDependencies() {
+    const platformError = await (0, runtime_1.ensureSupportedPlatform)();
+    if (platformError) {
+        return {
+            ok: false,
+            error: platformError,
+        };
+    }
+    const deviceInfo = await (0, runtime_1.loadDeviceInfo)();
+    if (!deviceInfo.ok) {
+        return {
+            ok: false,
+            error: deviceInfo.error,
+        };
+    }
+    const rnfs = await (0, runtime_1.loadRNFS)();
+    if (!rnfs.ok) {
+        return {
+            ok: false,
+            error: rnfs.error,
+        };
+    }
+    const unzipFile = await (0, runtime_1.loadUnzip)();
+    if (!unzipFile.ok) {
+        return {
+            ok: false,
+            error: unzipFile.error,
+        };
+    }
+    return {
+        ok: true,
+        deviceInfo: deviceInfo.module,
+        rnfs: rnfs.module,
+        unzipFile: unzipFile.module,
+    };
+}
+async function getBuildVersion() {
+    const deviceInfo = await (0, runtime_1.loadDeviceInfo)();
+    if (!deviceInfo.ok) {
+        return deviceInfo.error;
+    }
+    try {
+        return deviceInfo.module.getVersion();
+    }
+    catch (cause) {
+        return (0, logger_1.createError)('INVALID_DEPENDENCY', 'Falha ao executar getVersion() de "react-native-device-info".', cause);
+    }
+}
+async function downloadBundleArchive(fromUrl, toFile) {
+    const rnfs = await (0, runtime_1.loadRNFS)();
+    if (!rnfs.ok) {
+        return rnfs.error;
+    }
+    try {
+        return await rnfs.module.downloadFile({
+            fromUrl,
+            toFile,
+        }).promise;
+    }
+    catch (cause) {
+        return (0, logger_1.createError)('DOWNLOAD_FAILED', 'Falha ao baixar o bundle remoto.', cause);
+    }
+}
+async function getVersao() {
+    return (0, DBSQL_1.buscaVersao)();
+}
+async function checkUpdate(antes, depois) {
+    const versaoLocal = await (0, DBSQL_1.buscaVersao)();
+    const platformError = await (0, runtime_1.ensureSupportedPlatform)();
+    if (platformError) {
+        return toCheckErrorResult(platformError, versaoLocal);
+    }
+    const projectIdResult = await (0, functions_1.buscProjetoId)();
+    if (!projectIdResult.ok) {
+        return toCheckErrorResult(projectIdResult.error, versaoLocal);
+    }
+    const buildVersion = await getBuildVersion();
+    if (typeof buildVersion !== 'string') {
+        return toCheckErrorResult(buildVersion, versaoLocal);
+    }
+    const remoteVersion = await (0, network_1.requestRemoteVersion)(API_BASE_URL, projectIdResult.projectId, buildVersion);
+    if (!remoteVersion.ok) {
+        return toCheckErrorResult(remoteVersion.error, versaoLocal);
+    }
+    const versaoAtual = versaoLocal.versao;
+    const versaoRemota = remoteVersion.data.versao;
+    if (versaoRemota === versaoAtual) {
+        return {
+            status: 'up-to-date',
+            version: versaoLocal,
+        };
+    }
+    const result = await atualizar(versaoRemota, projectIdResult.projectId, antes, depois);
+    if (result.status === 'error') {
+        return {
+            status: 'error',
+            error: result.error,
+            version: versaoLocal,
+        };
+    }
+    return {
+        status: 'updated',
+        direction: versaoRemota > versaoAtual ? 'upgrade' : 'rollback',
+        previousVersion: versaoLocal,
+        targetVersion: versaoRemota,
+        restartRequired: true,
+    };
+}
+async function atualizar(versao, projetoId, antes, depois) {
+    const dependencies = await loadUpdateDependencies();
+    if (!dependencies.ok) {
+        return toUpdateErrorResult(dependencies.error);
+    }
+    const { deviceInfo, rnfs, unzipFile } = dependencies;
+    let deviceId;
+    try {
+        deviceId = await deviceInfo.getUniqueId();
+    }
+    catch (cause) {
+        return toUpdateErrorResult((0, logger_1.createError)('INVALID_DEPENDENCY', 'Falha ao executar getUniqueId() de "react-native-device-info".', cause));
+    }
+    const localPath = rnfs.DocumentDirectoryPath;
+    const localPathBundle = `${localPath}/index.android.bundle`;
+    const localPathTemp = `${localPath}/temp-cdd`;
+    const localArchivePath = `${localPathTemp}/bundle-update.zip`;
+    const bundleUrl = `${API_BASE_URL}/bundle/downloadFile?projetoId=${projetoId}` +
+        `&versao=${versao}&deviceId=${deviceId}`;
+    try {
+        const tempDirError = await (0, bundle_1.ensureTempDirectory)(rnfs, localPathTemp);
+        if (tempDirError) {
+            return toUpdateErrorResult(tempDirError);
+        }
+        const localPathTempBundle = `${localPathTemp}/index.android.bundle`;
+        await runCallback(antes);
+        const downloadResult = await downloadBundleArchive(bundleUrl, localArchivePath);
+        if ('code' in downloadResult) {
+            return toUpdateErrorResult(downloadResult);
+        }
+        if (downloadResult.statusCode !== 200) {
+            const cleanupError = await (0, bundle_1.removeFileIfExists)(rnfs, localArchivePath);
+            if (cleanupError) {
+                return toUpdateErrorResult(cleanupError);
+            }
+            return toUpdateErrorResult((0, logger_1.createError)('DOWNLOAD_FAILED', `O download do bundle retornou HTTP ${downloadResult.statusCode}.`));
+        }
+        const unzipError = await (0, bundle_1.unzipBundleArchive)(rnfs, unzipFile, localArchivePath, localPathTemp);
+        if (unzipError) {
+            return toUpdateErrorResult(unzipError);
+        }
+        const moveAssetsError = await (0, bundle_1.moveExtractedAssets)(rnfs, localPathTemp, localPath);
+        if (moveAssetsError) {
+            return toUpdateErrorResult(moveAssetsError);
+        }
+        const moveBundleError = await (0, bundle_1.moveExtractedBundle)(rnfs, localPathTempBundle, localPathBundle);
+        if (moveBundleError) {
+            return toUpdateErrorResult(moveBundleError);
+        }
+        await (0, DBSQL_1.salvarVersao)(versao);
+        return {
+            status: 'updated',
+            appliedVersion: versao,
+            restartRequired: true,
+        };
+    }
+    catch (cause) {
+        return toUpdateErrorResult((0, logger_1.createError)('UNKNOWN_ERROR', 'Erro inesperado ao aplicar atualização.', cause));
+    }
+    finally {
+        const cleanupError = await (0, bundle_1.cleanupTempDirectory)(rnfs, localPathTemp);
+        if (cleanupError) {
+            (0, logger_1.logError)(cleanupError.message, {
+                code: cleanupError.code,
+                cause: cleanupError.cause,
+            });
+        }
+        await runCallback(depois);
+    }
+}
+const vkdeployPush = {
+    getVersao,
+    checkUpdate,
+    atualizar,
+    setLogger: logger_1.setLogger,
+    resetLogger: logger_1.resetLogger,
+};
+exports.default = vkdeployPush;

package/dist/logger.d.ts

@@ -0,0 +1,8 @@
+import type { LoggerContext, VkDeployError, VkDeployErrorCode, VkDeployLogger } from './types';
+export declare function setLogger(logger: VkDeployLogger): void;
+export declare function resetLogger(): void;
+export declare function getLogger(): VkDeployLogger;
+export declare function logInfo(message: string, context?: LoggerContext): void;
+export declare function logWarn(message: string, context?: LoggerContext): void;
+export declare function logError(message: string, context?: LoggerContext): void;
+export declare function createError(code: VkDeployErrorCode, message: string, cause?: unknown): VkDeployError;

package/dist/logger.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setLogger = setLogger;
+exports.resetLogger = resetLogger;
+exports.getLogger = getLogger;
+exports.logInfo = logInfo;
+exports.logWarn = logWarn;
+exports.logError = logError;
+exports.createError = createError;
+const PREFIX = '[vkdeploy-push]';
+const defaultLogger = {
+    info(message, context) {
+        console.info(`${PREFIX} ${message}`, context !== null && context !== void 0 ? context : {});
+    },
+    warn(message, context) {
+        console.warn(`${PREFIX} ${message}`, context !== null && context !== void 0 ? context : {});
+    },
+    error(message, context) {
+        console.error(`${PREFIX} ${message}`, context !== null && context !== void 0 ? context : {});
+    },
+};
+let activeLogger = defaultLogger;
+function setLogger(logger) {
+    activeLogger = logger;
+}
+function resetLogger() {
+    activeLogger = defaultLogger;
+}
+function getLogger() {
+    return activeLogger;
+}
+function logInfo(message, context) {
+    activeLogger.info(message, context);
+}
+function logWarn(message, context) {
+    activeLogger.warn(message, context);
+}
+function logError(message, context) {
+    activeLogger.error(message, context);
+}
+function createError(code, message, cause) {
+    return {
+        code,
+        message,
+        cause,
+    };
+}

package/dist/network.d.ts

@@ -0,0 +1,11 @@
+import type { RemoteVersionResponse, VkDeployError } from './types';
+type Result<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: VkDeployError;
+};
+export declare function requestRemoteVersion(apiBaseUrl: string, projectId: string, buildVersion: string): Promise<Result<RemoteVersionResponse>>;
+export declare function resolveBundleFileName(bundleUrl: string): Promise<string>;
+export {};

package/dist/network.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestRemoteVersion = requestRemoteVersion;
+exports.resolveBundleFileName = resolveBundleFileName;
+const logger_1 = require("./logger");
+async function requestRemoteVersion(apiBaseUrl, projectId, buildVersion) {
+    try {
+        const response = await fetch(`${apiBaseUrl}/versao`, {
+            method: 'POST',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                projetoId: projectId,
+                versaoBuild: buildVersion,
+            }),
+        });
+        if (!response.ok) {
+            return {
+                ok: false,
+                error: (0, logger_1.createError)('REMOTE_REQUEST_FAILED', `Erro ao consultar versão remota: HTTP ${response.status}`),
+            };
+        }
+        const data = (await response.json());
+        if (typeof data.versao !== 'number' || Number.isNaN(data.versao)) {
+            return {
+                ok: false,
+                error: (0, logger_1.createError)('INVALID_REMOTE_RESPONSE', 'A resposta da API de versão não contém um campo "versao" válido.'),
+            };
+        }
+        return {
+            ok: true,
+            data: {
+                versao: data.versao,
+                mandatori: data.mandatori,
+            },
+        };
+    }
+    catch (cause) {
+        return {
+            ok: false,
+            error: (0, logger_1.createError)('REMOTE_REQUEST_FAILED', 'Falha ao consultar a versão remota.', cause),
+        };
+    }
+}
+async function resolveBundleFileName(bundleUrl) {
+    var _a;
+    try {
+        const response = await fetch(bundleUrl, { method: 'HEAD' });
+        const contentDisposition = response.headers.get('Content-Disposition');
+        if (!contentDisposition) {
+            return 'index.android.bundle';
+        }
+        const match = contentDisposition.match(/filename="(.+?)"/);
+        return (_a = match === null || match === void 0 ? void 0 : match[1]) !== null && _a !== void 0 ? _a : 'index.android.bundle';
+    }
+    catch {
+        return 'index.android.bundle';
+    }
+}

package/dist/runtime.d.ts

@@ -0,0 +1,53 @@
+import type { VkDeployError, VersaoInfo } from './types';
+export type RNFSDirEntry = {
+    path: string;
+    name: string;
+    isDirectory(): boolean;
+    isFile(): boolean;
+};
+export type RNFSStatResult = {
+    isDirectory(): boolean;
+};
+export type RNFSModule = {
+    DocumentDirectoryPath: string;
+    exists(path: string): Promise<boolean>;
+    writeFile(path: string, contents: string, encoding?: string): Promise<void>;
+    readFile(path: string, encoding?: string): Promise<string>;
+    stat(path: string): Promise<RNFSStatResult>;
+    mkdir(path: string): Promise<void>;
+    readDir(path: string): Promise<RNFSDirEntry[]>;
+    moveFile(from: string, to: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+    existsAssets(path: string): Promise<boolean>;
+    readFileAssets(path: string, encoding?: string): Promise<string>;
+    downloadFile(options: {
+        fromUrl: string;
+        toFile: string;
+    }): {
+        promise: Promise<{
+            statusCode: number;
+        }>;
+    };
+};
+export type DeviceInfoModule = {
+    getVersion(): string;
+    getUniqueId(): string | Promise<string>;
+};
+type ZipArchiveModule = {
+    unzip(source: string, target: string): Promise<unknown>;
+};
+export type UnzipFunction = ZipArchiveModule['unzip'];
+type ModuleLoadResult<T> = {
+    ok: true;
+    module: T;
+} | {
+    ok: false;
+    error: VkDeployError;
+};
+export declare function buildVersionInfo(bundle: string, versao: number): VersaoInfo;
+export declare function ensureSupportedPlatform(): Promise<VkDeployError | undefined>;
+export declare function loadRNFS(): Promise<ModuleLoadResult<RNFSModule>>;
+export declare function loadDeviceInfo(): Promise<ModuleLoadResult<DeviceInfoModule>>;
+export declare function loadUnzip(): Promise<ModuleLoadResult<UnzipFunction>>;
+export declare function getSafeBundleVersion(): Promise<string>;
+export {};

package/dist/runtime.js

@@ -0,0 +1,173 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildVersionInfo = buildVersionInfo;
+exports.ensureSupportedPlatform = ensureSupportedPlatform;
+exports.loadRNFS = loadRNFS;
+exports.loadDeviceInfo = loadDeviceInfo;
+exports.loadUnzip = loadUnzip;
+exports.getSafeBundleVersion = getSafeBundleVersion;
+const logger_1 = require("./logger");
+const UNKNOWN_BUNDLE_VERSION = '0.0.0';
+const loggedMessages = new Set();
+function logOnce(key, level, message, details) {
+    if (loggedMessages.has(key)) {
+        return;
+    }
+    loggedMessages.add(key);
+    if (level === 'warn') {
+        (0, logger_1.logWarn)(message, details);
+        return;
+    }
+    (0, logger_1.logError)(message, details);
+}
+function normalizeModule(module) {
+    var _a;
+    return ((_a = module.default) !== null && _a !== void 0 ? _a : module);
+}
+async function importModule(moduleName) {
+    try {
+        const imported = (await Promise.resolve(`${moduleName}`).then(s => __importStar(require(s))));
+        return {
+            ok: true,
+            module: normalizeModule(imported),
+        };
+    }
+    catch (cause) {
+        const error = (0, logger_1.createError)('MISSING_DEPENDENCY', `Não foi possível carregar "${moduleName}". Verifique se a biblioteca está instalada e linkada corretamente no app consumidor.`, cause);
+        logOnce(`import:${moduleName}`, 'error', error.message, { code: error.code, cause });
+        return {
+            ok: false,
+            error,
+        };
+    }
+}
+function buildVersionInfo(bundle, versao) {
+    return {
+        bundle,
+        versao,
+        titulo: `${bundle}.${versao}`,
+    };
+}
+async function ensureSupportedPlatform() {
+    var _a;
+    const reactNative = await importModule('react-native');
+    if (!reactNative.ok) {
+        return reactNative.error;
+    }
+    const os = (_a = reactNative.module.Platform) === null || _a === void 0 ? void 0 : _a.OS;
+    if (os === 'android') {
+        return undefined;
+    }
+    const error = (0, logger_1.createError)('UNSUPPORTED_PLATFORM', `A biblioteca atualmente suporta apenas Android. Plataforma recebida: ${os !== null && os !== void 0 ? os : 'desconhecida'}.`);
+    logOnce('platform:unsupported', 'warn', error.message, { code: error.code, platform: os });
+    return error;
+}
+async function loadRNFS() {
+    const imported = await importModule('react-native-fs');
+    if (!imported.ok) {
+        return imported;
+    }
+    const rnfs = imported.module;
+    if (typeof rnfs.DocumentDirectoryPath !== 'string' ||
+        typeof rnfs.exists !== 'function' ||
+        typeof rnfs.readFile !== 'function' ||
+        typeof rnfs.writeFile !== 'function') {
+        const error = (0, logger_1.createError)('INVALID_DEPENDENCY', '"react-native-fs" foi carregado, mas a API esperada não está disponível.');
+        logOnce('validate:react-native-fs', 'error', error.message, { code: error.code });
+        return {
+            ok: false,
+            error,
+        };
+    }
+    return imported;
+}
+async function loadDeviceInfo() {
+    const imported = await importModule('react-native-device-info');
+    if (!imported.ok) {
+        return imported;
+    }
+    const deviceInfo = imported.module;
+    if (typeof deviceInfo.getVersion !== 'function' ||
+        typeof deviceInfo.getUniqueId !== 'function') {
+        const error = (0, logger_1.createError)('INVALID_DEPENDENCY', '"react-native-device-info" foi carregado, mas a API esperada não está disponível.');
+        logOnce('validate:react-native-device-info', 'error', error.message, {
+            code: error.code,
+        });
+        return {
+            ok: false,
+            error,
+        };
+    }
+    return imported;
+}
+async function loadUnzip() {
+    const imported = await importModule('react-native-zip-archive');
+    if (!imported.ok) {
+        return imported;
+    }
+    const unzip = imported.module.unzip;
+    if (typeof unzip !== 'function') {
+        const error = (0, logger_1.createError)('INVALID_DEPENDENCY', '"react-native-zip-archive" foi carregado, mas a API esperada não está disponível.');
+        logOnce('validate:react-native-zip-archive', 'error', error.message, {
+            code: error.code,
+        });
+        return {
+            ok: false,
+            error,
+        };
+    }
+    return {
+        ok: true,
+        module: unzip,
+    };
+}
+async function getSafeBundleVersion() {
+    const deviceInfo = await loadDeviceInfo();
+    if (!deviceInfo.ok) {
+        return UNKNOWN_BUNDLE_VERSION;
+    }
+    try {
+        return deviceInfo.module.getVersion();
+    }
+    catch (cause) {
+        const error = (0, logger_1.createError)('INVALID_DEPENDENCY', 'Falha ao executar getVersion() de "react-native-device-info".', cause);
+        logOnce('runtime:react-native-device-info:getVersion', 'error', error.message, {
+            code: error.code,
+            cause,
+        });
+        return UNKNOWN_BUNDLE_VERSION;
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,54 @@
+export type UpdateLifecycleCallback = () => void | Promise<void>;
+export interface VersaoInfo {
+    bundle: string;
+    versao: number;
+    titulo: string;
+}
+export interface VersionamentoConfig {
+    app_secret: string;
+}
+export interface RemoteVersionResponse {
+    versao: number;
+    mandatori?: boolean;
+}
+export type VkDeployErrorCode = 'UNSUPPORTED_PLATFORM' | 'MISSING_DEPENDENCY' | 'INVALID_DEPENDENCY' | 'CONFIG_NOT_FOUND' | 'INVALID_CONFIG' | 'REMOTE_REQUEST_FAILED' | 'INVALID_REMOTE_RESPONSE' | 'DOWNLOAD_FAILED' | 'UNZIP_FAILED' | 'FILESYSTEM_ERROR' | 'UNKNOWN_ERROR';
+export interface VkDeployError {
+    code: VkDeployErrorCode;
+    message: string;
+    cause?: unknown;
+}
+export interface LoggerContext {
+    [key: string]: unknown;
+}
+export interface VkDeployLogger {
+    info(message: string, context?: LoggerContext): void;
+    warn(message: string, context?: LoggerContext): void;
+    error(message: string, context?: LoggerContext): void;
+}
+export interface UpToDateCheckResult {
+    status: 'up-to-date';
+    version: VersaoInfo;
+}
+export interface UpdatedCheckResult {
+    status: 'updated';
+    direction: 'upgrade' | 'rollback';
+    previousVersion: VersaoInfo;
+    targetVersion: number;
+    restartRequired: true;
+}
+export interface ErrorCheckResult {
+    status: 'error';
+    error: VkDeployError;
+    version?: VersaoInfo;
+}
+export type CheckUpdateResult = UpToDateCheckResult | UpdatedCheckResult | ErrorCheckResult;
+export interface UpdatedResult {
+    status: 'updated';
+    appliedVersion: number;
+    restartRequired: true;
+}
+export interface ErrorUpdateResult {
+    status: 'error';
+    error: VkDeployError;
+}
+export type AtualizarResult = UpdatedResult | ErrorUpdateResult;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/functions.d.ts

@@ -0,0 +1,10 @@
+import type { VkDeployError } from '../types';
+type ProjectIdResult = {
+    ok: true;
+    projectId: string;
+} | {
+    ok: false;
+    error: VkDeployError;
+};
+export declare function buscProjetoId(): Promise<ProjectIdResult>;
+export {};

package/dist/utils/functions.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buscProjetoId = buscProjetoId;
+const logger_1 = require("../logger");
+const runtime_1 = require("../runtime");
+const CONFIG_ASSET_PATH = 'versionamento-vktech-config.json';
+async function buscProjetoId() {
+    var _a;
+    const rnfs = await (0, runtime_1.loadRNFS)();
+    if (!rnfs.ok) {
+        return {
+            ok: false,
+            error: rnfs.error,
+        };
+    }
+    const exists = await rnfs.module.existsAssets(CONFIG_ASSET_PATH);
+    if (!exists) {
+        return {
+            ok: false,
+            error: (0, logger_1.createError)('CONFIG_NOT_FOUND', 'Arquivo de configuração não encontrado em android/app/src/main/assets/versionamento-vktech-config.json.'),
+        };
+    }
+    try {
+        const fileContent = await rnfs.module.readFileAssets(CONFIG_ASSET_PATH, 'utf8');
+        const jsonData = JSON.parse(fileContent);
+        const appSecret = (_a = jsonData.app_secret) === null || _a === void 0 ? void 0 : _a.trim();
+        if (!appSecret) {
+            return {
+                ok: false,
+                error: (0, logger_1.createError)('INVALID_CONFIG', 'O campo "app_secret" não foi informado no arquivo de configuração.'),
+            };
+        }
+        return {
+            ok: true,
+            projectId: appSecret,
+        };
+    }
+    catch (cause) {
+        return {
+            ok: false,
+            error: (0, logger_1.createError)('INVALID_CONFIG', 'Não foi possível ler ou interpretar o arquivo de configuração.', cause),
+        };
+    }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "vkdeploy-push",
+  "version": "1.0.0",
+  "description": "Biblioteca React Native para versionamento e atualizacao remota de bundle Android.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "react-native": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch",
+    "prepare": "npm run build",
+    "pack:check": "npm run build && npm pack --dry-run --cache /tmp/npm-cache",
+    "test": "npm run build && node --test tests/**/*.test.js"
+  },
+  "keywords": [
+    "react-native",
+    "android",
+    "bundle",
+    "ota",
+    "update"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "react-native-device-info": "^11.1.0",
+    "react-native-fs": "^2.20.0",
+    "react-native-zip-archive": "^7.0.1"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "react-native": ">=0.71"
+  },
+  "devDependencies": {
+    "react": "19.2.3",
+    "react-native": "0.85.3",
+    "typescript": "^6.0.3"
+  }
+}