@crowdin/app-project-module 0.108.0 → 1.0.0

package/out/util/credentials-masker.js

@@ -8,16 +8,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maskKey = exports.postRequestCredentialsMasker = exports.getRequestCredentialsMasker = void 0;
-const lodash_get_1 = __importDefault(require("lodash.get"));
-const index_1 = require("./index");
-const index_2 = require("../index");
-const crowdin_client_1 = require("../middlewares/crowdin-client");
+exports.postRequestCredentialsMasker = exports.maskKey = exports.getRequestCredentialsMasker = void 0;
 const crowdin_apps_functions_1 = require("@crowdin/crowdin-apps-functions");
+const index_1 = require("../index");
+const crowdin_client_1 = require("../middlewares/crowdin-client");
+const index_2 = require("./index");
 function maskKey(key) {
     const maskWith = '*';
     const unmaskedCharsAtEnd = 3;
@@ -29,18 +25,16 @@ function getMaskableFieldsKeys(moduleConfig) {
     if (!moduleConfig.formUiSchema) {
         return [];
     }
-    return Object.keys(moduleConfig.formUiSchema).filter((fieldKey) => {
-        return (0, lodash_get_1.default)(moduleConfig, `formUiSchema[${fieldKey}]['ui:widget']`) === 'password';
-    });
+    return Object.keys(moduleConfig.formUiSchema).filter((fieldKey) => { var _a, _b; return ((_b = (_a = moduleConfig === null || moduleConfig === void 0 ? void 0 : moduleConfig.formUiSchema) === null || _a === void 0 ? void 0 : _a[fieldKey]) === null || _b === void 0 ? void 0 : _b['ui:widget']) === 'password'; });
 }
 function getRequestCredentialsMasker({ moduleConfig, dataPath = 'formData', }) {
     return function (req, res, next) {
-        // we can't find "password" fields without ui schema
-        if (!moduleConfig || !moduleConfig.formSchema || !moduleConfig.formUiSchema) {
+        if (req.__credentialsMaskerApplied) {
             return next();
         }
-        // temporary
-        if (!moduleConfig.maskPasswords) {
+        req.__credentialsMaskerApplied = true;
+        // we can't find "password" fields without ui schema
+        if (!moduleConfig || !moduleConfig.formSchema || !moduleConfig.formUiSchema) {
             return next();
         }
         const maskableFieldsKeys = getMaskableFieldsKeys(moduleConfig);
@@ -69,13 +63,13 @@ function getRequestCredentialsMasker({ moduleConfig, dataPath = 'formData', }) {
 }
 exports.getRequestCredentialsMasker = getRequestCredentialsMasker;
 function postRequestCredentialsMasker(moduleConfig, credentialsExtractor) {
-    return (0, index_1.runAsyncWrapper)((req, res, next) => __awaiter(this, void 0, void 0, function* () {
+    return (0, index_2.runAsyncWrapper)((req, res, next) => __awaiter(this, void 0, void 0, function* () {
         var _a;
-        if (!moduleConfig || !moduleConfig.formSchema || !moduleConfig.formUiSchema) {
+        if (req.__credentialsMaskerApplied) {
             return next();
         }
-        // temporary
-        if (!moduleConfig.maskPasswords) {
+        req.__credentialsMaskerApplied = true;
+        if (!moduleConfig || !moduleConfig.formSchema || !moduleConfig.formUiSchema) {
             return next();
         }
         const fieldsKeysInRequest = Object.keys(((_a = req.body) === null || _a === void 0 ? void 0 : _a.data) || []);
@@ -88,7 +82,7 @@ function postRequestCredentialsMasker(moduleConfig, credentialsExtractor) {
             const jwtToken = (0, crowdin_client_1.getToken)(req) || '';
             const jwtPayload = yield (0, crowdin_apps_functions_1.validateJwtToken)(jwtToken, process.env.CROWDIN_CLIENT_SECRET || '');
             const crowdinId = `${jwtPayload.context.organization_id}`;
-            unmaskedFields = yield index_2.metadataStore.getMetadata(`form-data-${crowdinId}`);
+            unmaskedFields = yield index_1.metadataStore.getMetadata(`form-data-${crowdinId}`);
         }
         unmaskedFields = unmaskedFields || {};
         const maskableFieldsKeys = getMaskableFieldsKeys(moduleConfig);

package/out/util/cron.d.ts

@@ -0,0 +1,29 @@
+import { Config, UnauthorizedConfig } from '../types';
+export interface Cron {
+    /**
+     * Schedule a task to run on a cron expression
+     * @param expression - Cron expression (e.g., '0 * * * *' for hourly)
+     * @param task - Async task to execute
+     */
+    schedule(expression: string, task: () => Promise<void>): void;
+}
+/**
+ * Default Node.js cron handler that uses node-cron
+ */
+export declare class NodeCron implements Cron {
+    private cron;
+    private pendingSchedules;
+    private initialized;
+    constructor();
+    schedule(expression: string, task: () => Promise<void>): void;
+}
+/**
+ * Initialize the cron instance
+ * @param config - Client configuration
+ */
+export declare function initialize(config: Config | UnauthorizedConfig): void;
+/**
+ * Get the initialized cron instance
+ * @returns The cron instance
+ */
+export declare function getCron(): Cron;

package/out/util/cron.js

@@ -0,0 +1,87 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCron = exports.initialize = exports.NodeCron = void 0;
+const logger_1 = require("./logger");
+/**
+ * Default Node.js cron handler that uses node-cron
+ */
+class NodeCron {
+    constructor() {
+        this.pendingSchedules = [];
+        this.initialized = false;
+        // Dynamically import node-cron
+        Promise.resolve().then(() => __importStar(require('node-cron'))).then((nodeCron) => {
+            this.cron = nodeCron.default || nodeCron;
+            this.initialized = true;
+            // Schedule all pending tasks
+            this.pendingSchedules.forEach(({ expression, task }) => {
+                this.cron.schedule(expression, task);
+            });
+            this.pendingSchedules = [];
+        })
+            .catch((error) => {
+            console.error('Failed to load node-cron:', error);
+            throw new Error('node-cron is required for the default cron. Please install it or provide a custom cron in config.');
+        });
+    }
+    schedule(expression, task) {
+        if (this.initialized && this.cron) {
+            this.cron.schedule(expression, task);
+        }
+        else {
+            // Queue the task until node-cron is loaded
+            this.pendingSchedules.push({ expression, task });
+        }
+    }
+}
+exports.NodeCron = NodeCron;
+let cron;
+/**
+ * Initialize the cron instance
+ * @param config - Client configuration
+ */
+function initialize(config) {
+    if (config.cron) {
+        (0, logger_1.log)('Using custom cron implementation');
+        cron = config.cron;
+    }
+    else {
+        (0, logger_1.log)('Using default NodeCron implementation');
+        cron = new NodeCron();
+    }
+}
+exports.initialize = initialize;
+/**
+ * Get the initialized cron instance
+ * @returns The cron instance
+ */
+function getCron() {
+    if (!cron) {
+        throw new Error('Cron not initialized');
+    }
+    return cron;
+}
+exports.getCron = getCron;

package/out/util/index.d.ts

@@ -4,14 +4,24 @@ export declare class CodeError extends Error {
     code: number | undefined;
     constructor(message: string, code?: number);
 }
+export declare function extractBaseUrlFromRequest(req: Request): string;
 export declare function runAsyncWrapper(callback: Function): (req: Request | CrowdinClientRequest, res: Response, next: Function) => void;
 export declare function encryptData(config: Config, data: string): string;
 export declare function decryptData(config: Config, data: string): string;
 export declare function executeWithRetry<T>(func: () => Promise<T>, numOfRetries?: number): Promise<T>;
-export declare function getLogoUrl(moduleConfig?: ImagePath, modulePath?: string): string;
+export declare function getLogoUrl(config: Config | UnauthorizedConfig, moduleConfig?: ImagePath, modulePath?: string): string;
+/**
+ * Logo middleware with backwards compatibility
+ * Serves both /logo.png (backwards-compatible) and actual file name
+ * @param config - App configuration (required for Cloudflare Workers Assets support)
+ * @param moduleConfig - Module configuration with imagePath (optional, falls back to config.imagePath)
+ * @returns Express middleware
+ */
+export declare function serveLogo(config: Config | UnauthorizedConfig, moduleConfig?: ImagePath): (req: Request, res: Response, next: Function) => Promise<void>;
 export declare function isAuthorizedConfig(config: Config | UnauthorizedConfig): config is Config;
 export declare function isJson(string: string): boolean;
 export declare function isDefined(value: any): boolean;
+export declare function isString(value: any): value is string;
 export declare function getPreviousDate(days: number): Date;
 export declare function prepareFormDataMetadataId(req: CrowdinClientRequest, config: Config): Promise<string>;
 export declare function validateEmail(email: string | number): boolean;
@@ -19,3 +29,6 @@ export declare function getFormattedDate({ date, userTimezone }: {
     date: Date | number;
     userTimezone: string | undefined;
 }): string;
+export declare function kebabCase(str?: string): string;
+export declare function snakeCase(str?: string): string;
+export declare function uniqBy<T>(array: any, key: keyof T): T[];

package/out/util/index.js

@@ -32,12 +32,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFormattedDate = exports.validateEmail = exports.prepareFormDataMetadataId = exports.getPreviousDate = exports.isDefined = exports.isJson = exports.isAuthorizedConfig = exports.getLogoUrl = exports.executeWithRetry = exports.decryptData = exports.encryptData = exports.runAsyncWrapper = exports.CodeError = void 0;
-const crypto = __importStar(require("crypto-js"));
+exports.uniqBy = exports.snakeCase = exports.kebabCase = exports.getFormattedDate = exports.validateEmail = exports.prepareFormDataMetadataId = exports.getPreviousDate = exports.isString = exports.isDefined = exports.isJson = exports.isAuthorizedConfig = exports.serveLogo = exports.getLogoUrl = exports.executeWithRetry = exports.decryptData = exports.encryptData = exports.runAsyncWrapper = exports.extractBaseUrlFromRequest = exports.CodeError = void 0;
+const crowdin_apps_functions_1 = require("@crowdin/crowdin-apps-functions");
+const crypto = __importStar(require("crypto"));
 const storage_1 = require("../storage");
 const types_1 = require("../types");
+const jsx_renderer_1 = require("./jsx-renderer");
 const logger_1 = require("./logger");
-const crowdin_apps_functions_1 = require("@crowdin/crowdin-apps-functions");
+const static_files_1 = require("./static-files");
+/**
+ * Extract file name from path (works in both Node.js and Cloudflare Workers)
+ * Supports both Unix (/) and Windows (\) path separators
+ */
+function basename(filePath) {
+    // Replace all backslashes with forward slashes, then get the last segment
+    return filePath.replace(/\\/g, '/').split('/').pop();
+}
 class CodeError extends Error {
     constructor(message, code) {
         super(message);
@@ -45,6 +55,12 @@ class CodeError extends Error {
     }
 }
 exports.CodeError = CodeError;
+function extractBaseUrlFromRequest(req) {
+    const protocol = req.protocol;
+    const host = req.get('host');
+    return `${protocol}://${host}`;
+}
+exports.extractBaseUrlFromRequest = extractBaseUrlFromRequest;
 function isCrowdinClientRequest(req) {
     return req.crowdinContext;
 }
@@ -61,7 +77,9 @@ function handleError(err, req, res) {
         if (!res.headersSent) {
             const errorMessage = { message: (0, logger_1.getErrorMessage)(err), code };
             if ('integrationCredentials' in req) {
-                res.render('error', errorMessage);
+                const html = (0, jsx_renderer_1.renderJSXOnClient)({ name: 'error', props: errorMessage });
+                res.setHeader('Content-Type', 'text/html; charset=utf-8');
+                res.send(html);
             }
             else {
                 res.status(code).send({ error: errorMessage });
@@ -84,11 +102,38 @@ function runAsyncWrapper(callback) {
 }
 exports.runAsyncWrapper = runAsyncWrapper;
 function encryptData(config, data) {
-    return crypto.AES.encrypt(data, config.cryptoSecret || config.clientSecret).toString();
+    const secret = config.cryptoSecret || config.clientSecret;
+    const salt = crypto.randomBytes(8);
+    const password = Buffer.concat([Buffer.from(secret, 'binary'), salt]);
+    const hash = [];
+    let digest = password;
+    for (let i = 0; i < 3; i++) {
+        hash[i] = crypto.createHash('md5').update(digest).digest();
+        digest = Buffer.concat([hash[i], password]);
+    }
+    const keyDerivation = Buffer.concat(hash);
+    const key = keyDerivation.subarray(0, 32);
+    const iv = keyDerivation.subarray(32);
+    const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
+    return Buffer.concat([Buffer.from('Salted__', 'utf8'), salt, cipher.update(data), cipher.final()]).toString('base64');
 }
 exports.encryptData = encryptData;
 function decryptData(config, data) {
-    return crypto.AES.decrypt(data, config.cryptoSecret || config.clientSecret).toString(crypto.enc.Utf8);
+    const secret = config.cryptoSecret || config.clientSecret;
+    const cypher = Buffer.from(data, 'base64');
+    const salt = cypher.subarray(8, 16);
+    const password = Buffer.concat([Buffer.from(secret, 'binary'), salt]);
+    const md5Hashes = [];
+    let digest = password;
+    for (let i = 0; i < 3; i++) {
+        md5Hashes[i] = crypto.createHash('md5').update(digest).digest();
+        digest = Buffer.concat([md5Hashes[i], password]);
+    }
+    const key = Buffer.concat([md5Hashes[0], md5Hashes[1]]);
+    const iv = md5Hashes[2];
+    const contents = cypher.subarray(16);
+    const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
+    return decipher.update(contents, undefined, 'utf-8') + decipher.final('utf-8');
 }
 exports.decryptData = decryptData;
 function executeWithRetry(func, numOfRetries = 2) {
@@ -108,13 +153,36 @@ function executeWithRetry(func, numOfRetries = 2) {
     });
 }
 exports.executeWithRetry = executeWithRetry;
-function getLogoUrl(moduleConfig, modulePath) {
-    if (!moduleConfig && !modulePath) {
-        return '/logo.png';
+function getLogoUrl(config, moduleConfig, modulePath) {
+    // Extract file name from imagePath with fallback to config.imagePath
+    const imagePath = (moduleConfig === null || moduleConfig === void 0 ? void 0 : moduleConfig.imagePath) || config.imagePath;
+    const fileName = basename(imagePath);
+    if (!modulePath) {
+        return `/${fileName}`;
     }
-    return `/logo${modulePath}/logo.png`;
+    return `/logo${modulePath}/${fileName}`;
 }
 exports.getLogoUrl = getLogoUrl;
+/**
+ * Logo middleware with backwards compatibility
+ * Serves both /logo.png (backwards-compatible) and actual file name
+ * @param config - App configuration (required for Cloudflare Workers Assets support)
+ * @param moduleConfig - Module configuration with imagePath (optional, falls back to config.imagePath)
+ * @returns Express middleware
+ */
+function serveLogo(config, moduleConfig) {
+    const imagePath = (moduleConfig === null || moduleConfig === void 0 ? void 0 : moduleConfig.imagePath) || config.imagePath;
+    const fileName = basename(imagePath);
+    const fileHandler = (0, static_files_1.serveFile)(config, imagePath);
+    return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
+        // Match exact paths: /logo.png (backwards-compatible) or /{actual-file-name}
+        if (req.path === '/logo.png' || req.path === `/${fileName}`) {
+            return fileHandler(req, res, next);
+        }
+        next();
+    });
+}
+exports.serveLogo = serveLogo;
 function isAuthorizedConfig(config) {
     return !!config.clientId && !!config.clientSecret && config.authenticationType !== types_1.AuthenticationType.NONE;
 }
@@ -133,6 +201,10 @@ function isDefined(value) {
     return value !== undefined && value !== null;
 }
 exports.isDefined = isDefined;
+function isString(value) {
+    return typeof value === 'string' || value instanceof String;
+}
+exports.isString = isString;
 function getPreviousDate(days) {
     const date = new Date();
     date.setDate(date.getDate() - days);
@@ -182,3 +254,42 @@ function getFormattedDate({ date, userTimezone }) {
     }).format(date);
 }
 exports.getFormattedDate = getFormattedDate;
+function kebabCase(str) {
+    if (!str) {
+        return '';
+    }
+    return (str
+        // Insert dash between lowercase & uppercase
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        // Insert dash between letters & numbers
+        .replace(/([a-zA-Z])([0-9])/g, '$1-$2')
+        .replace(/([0-9])([a-zA-Z])/g, '$1-$2')
+        // Replace spaces & underscores with dash
+        .replace(/[\s_]+/g, '-')
+        // Normalize multiple dashes
+        .replace(/-+/g, '-')
+        // Lowercase everything
+        .toLowerCase());
+}
+exports.kebabCase = kebabCase;
+function snakeCase(str) {
+    return kebabCase(str).replace(/-/g, '_');
+}
+exports.snakeCase = snakeCase;
+function uniqBy(array, key) {
+    if (!Array.isArray(array)) {
+        return [];
+    }
+    const seen = new Set();
+    return array.filter((item) => {
+        const k = item[key];
+        if (seen.has(k)) {
+            return false;
+        }
+        else {
+            seen.add(k);
+            return true;
+        }
+    });
+}
+exports.uniqBy = uniqBy;

package/out/util/jsx-renderer.d.ts

@@ -0,0 +1,14 @@
+import type { FC } from 'react';
+/**
+ * Renders a React component to HTML string
+ * Uses React Server-Side Rendering (renderToStaticMarkup)
+ */
+export declare function renderJSXOnServer<P = any>(Component: FC<P>, props: P): string;
+/**
+ * Renders a React component to HTML string to be hydrated on client side
+ */
+export declare function renderJSXOnClient({ name, props, withHead, }: {
+    name: string;
+    props: any;
+    withHead?: boolean;
+}): string;

package/out/util/jsx-renderer.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderJSXOnClient = exports.renderJSXOnServer = void 0;
+const server_1 = require("react-dom/server");
+const views_1 = require("../views");
+/**
+ * Renders a React component to HTML string
+ * Uses React Server-Side Rendering (renderToStaticMarkup)
+ */
+function renderJSXOnServer(Component, props) {
+    const element = Component(props);
+    return '<!DOCTYPE html>' + (0, server_1.renderToStaticMarkup)(element);
+}
+exports.renderJSXOnServer = renderJSXOnServer;
+/**
+ * Renders a React component to HTML string to be hydrated on client side
+ */
+function renderJSXOnClient({ name, props, withHead = true, }) {
+    const head = withHead ? (0, server_1.renderToStaticMarkup)((0, views_1.Head)(props)) : '';
+    return `
+<!DOCTYPE html>
+<html>
+    ${head}
+    <body>
+        <div id="root"></div>
+    <script>
+      // Make props available to client JS
+      window.__PAGE_PROPS__ = ${JSON.stringify(props).replace(/</g, '\\u003c')};
+    </script>
+    <script type="module" src="/assets/ui/${name}.bundle.js"></script>
+    </body>
+</html>
+    `;
+}
+exports.renderJSXOnClient = renderJSXOnClient;

package/out/util/logger.d.ts

@@ -32,6 +32,7 @@ export declare class AppUserModuleError extends AppModuleError {
 }
 export declare class AppModuleAggregateError extends Error {
     errors: Error[] | AppModuleError[] | AppUserModuleError[];
+    isPartialSuccess?: boolean;
     constructor(errors: Error[] | AppModuleError[] | AppUserModuleError[], message: string);
 }
 export declare function handleUserError({ action, error, crowdinId, clientId, }: {

package/out/util/logger.js

@@ -62,7 +62,7 @@ function log(message, context) {
     var _a, _b, _c;
     if (logConfig === null || logConfig === void 0 ? void 0 : logConfig.enabled) {
         if (logConfig.log) {
-            logConfig.log(message, context);
+            logConfig.log({ message, context });
         }
         else {
             let prefix = `[${new Date().toISOString()}]`;
@@ -96,7 +96,7 @@ exports.log = log;
 function logError(e, context) {
     var _a, _b, _c;
     if (onError) {
-        onError(e, context);
+        onError({ error: e, context });
     }
     else {
         if (context) {

package/out/util/static-files.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Static Files Abstraction Layer
+ * Dual compatibility: Node.js (Express) + Cloudflare Workers (Assets Fetcher)
+ */
+/// <reference types="serve-static" />
+import express, { Request, Response } from 'express';
+import { Config, UnauthorizedConfig } from '../types';
+/**
+ * Serve static directory with dual compatibility
+ * @param config - App configuration
+ * @param staticPath - Path to static directory
+ */
+export declare function serveStatic(config: Config | UnauthorizedConfig, staticPath: string): ((req: Request, res: Response, next: Function) => Promise<void>) | import("serve-static").RequestHandler<express.Response<any, Record<string, any>>>;
+/**
+ * Serve single file (e.g., logo.png, icons/star.svg) with dual compatibility
+ * @param config - App configuration
+ * @param filePath - Path to file
+ */
+export declare function serveFile(config: Config | UnauthorizedConfig, filePath: string): (req: Request, res: Response, next: Function) => Promise<void>;

package/out/util/static-files.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * Static Files Abstraction Layer
+ * Dual compatibility: Node.js (Express) + Cloudflare Workers (Assets Fetcher)
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serveFile = exports.serveStatic = void 0;
+const express_1 = __importDefault(require("express"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Proxy Workers Assets response to Express response
+ */
+function proxyAssetsResponse(fetcher, assetPath, baseUrl, req, res, next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (assetPath === '/') {
+                return next();
+            }
+            const assetUrl = new URL(assetPath, baseUrl);
+            const response = yield fetcher.fetch(assetUrl.toString());
+            if (!response.ok) {
+                return next();
+            }
+            const body = yield response.arrayBuffer();
+            const contentType = response.headers.get('content-type');
+            if (contentType) {
+                res.setHeader('Content-Type', contentType);
+            }
+            res.send(Buffer.from(body));
+        }
+        catch (err) {
+            next(err);
+        }
+    });
+}
+/**
+ * Serve static directory with dual compatibility
+ * @param config - App configuration
+ * @param staticPath - Path to static directory
+ */
+function serveStatic(config, staticPath) {
+    var _a;
+    if ((_a = config.assetsConfig) === null || _a === void 0 ? void 0 : _a.fetcher) {
+        const assetsFetcher = config.assetsConfig.fetcher;
+        return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
+            const assetPath = `/${staticPath}/${req.path}`.replace(/\/+/g, '/');
+            yield proxyAssetsResponse(assetsFetcher, assetPath, config.baseUrl, req, res, next);
+        });
+    }
+    const rootDir = path_1.default.dirname(__dirname);
+    const absolutePath = path_1.default.isAbsolute(staticPath) ? staticPath : path_1.default.join(rootDir, staticPath);
+    return express_1.default.static(absolutePath);
+}
+exports.serveStatic = serveStatic;
+/**
+ * Serve single file (e.g., logo.png, icons/star.svg) with dual compatibility
+ * @param config - App configuration
+ * @param filePath - Path to file
+ */
+function serveFile(config, filePath) {
+    return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if ((_a = config.assetsConfig) === null || _a === void 0 ? void 0 : _a.fetcher) {
+            const assetsFetcher = config.assetsConfig.fetcher;
+            const assetPath = filePath.startsWith('/') ? filePath : `/${filePath}`;
+            yield proxyAssetsResponse(assetsFetcher, assetPath, config.baseUrl, req, res, next);
+        }
+        else {
+            const rootDir = path_1.default.dirname(__dirname);
+            const absolutePath = path_1.default.isAbsolute(filePath) ? filePath : path_1.default.join(rootDir, filePath);
+            res.sendFile(absolutePath);
+        }
+    });
+}
+exports.serveFile = serveFile;

package/out/util/subscription.js

@@ -71,7 +71,7 @@ function checkSubscription({ config, token, organization, accountType, }) {
                 return { expired, subscribeLink, daysLeft, type: types_1.SubscriptionInfoType.TRIAL };
             }
             if (config.onError) {
-                config.onError(e);
+                config.onError({ error: e });
             }
             else {
                 console.error(e);

package/out/views/AboutPage.d.ts

@@ -0,0 +1,10 @@
+import { FC } from 'react';
+interface AboutPageProps {
+    name: string;
+    logo: string;
+    manifest: string;
+    storeLink?: string;
+    showDebugLink?: boolean;
+}
+export declare const AboutPage: FC<AboutPageProps>;
+export {};