@crowdin/app-project-module 0.105.1 → 0.107.0-cf-0

package/out/storage/index.js

@@ -1,5 +1,4 @@
 "use strict";
-/* eslint-disable @typescript-eslint/camelcase */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -42,6 +41,7 @@ const logger_1 = require("../util/logger");
 const mysql_1 = require("./mysql");
 const postgre_1 = require("./postgre");
 const sqlite_1 = require("./sqlite");
+const d1_1 = require("./d1");
 const path_1 = __importStar(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const child_process_1 = require("child_process");
@@ -63,7 +63,13 @@ exports.TABLES = {
 let storage;
 function initialize(config) {
     return __awaiter(this, void 0, void 0, function* () {
-        if (config.postgreConfig) {
+        if (config.d1Config) {
+            (0, logger_1.log)('Using Cloudflare D1 database');
+            storage = new d1_1.D1Storage(config.d1Config);
+            // Skip migration for D1 - it will be done lazily on first request
+            return;
+        }
+        else if (config.postgreConfig) {
             (0, logger_1.log)('Using PostgreSQL database');
             let dumpDirectory = null;
             if (config.migrateToPostgreFromSQLite) {

package/out/storage/mysql.js

@@ -1,8 +1,5 @@
 "use strict";
 /* eslint-disable no-unused-expressions */
-/* eslint-disable @typescript-eslint/no-var-requires */
-/* eslint-disable @typescript-eslint/ban-ts-ignore */
-/* eslint-disable @typescript-eslint/camelcase */
 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) {

package/out/storage/postgre.js

@@ -1,6 +1,5 @@
 "use strict";
 /* eslint-disable no-unused-expressions */
-/* eslint-disable @typescript-eslint/camelcase */
 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) {

package/out/storage/sqlite.js

@@ -1,8 +1,5 @@
 "use strict";
-/* eslint-disable @typescript-eslint/camelcase */
-/* eslint-disable @typescript-eslint/ban-ts-ignore */
 /* eslint-disable no-unused-expressions */
-/* eslint-disable @typescript-eslint/no-var-requires */
 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) {

package/out/types.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="node" />
+/// <reference types="node" />
 import Crowdin from '@crowdin/crowdin-api-client';
 import { JwtPayload, VerifyOptions } from '@crowdin/crowdin-apps-functions';
 import { Request } from 'express';
@@ -10,6 +12,8 @@ import { IntegrationLogic } from './modules/integration/types';
 import { Storage } from './storage';
 import { MySQLStorageConfig } from './storage/mysql';
 import { PostgreStorageConfig } from './storage/postgre';
+import { D1StorageConfig } from './storage/d1';
+import type { Fetcher } from '@cloudflare/workers-types';
 import { ApiModule } from './modules/api/types';
 import { LogErrorFunction, LogFunction } from './util/logger';
 import { AiProviderModule } from './modules/ai-provider/types';
@@ -21,6 +25,8 @@ import { WorkflowStepTypeModule } from './modules/workflow-step-type/types';
 import { AiRequestProcessorModule, AiStreamProcessorModule } from './modules/ai-request-processors/types';
 import { AutomationActionModule } from './modules/automation-action/types';
 import { AuthGuardModule } from './modules/auth-guard/types';
+import { Cron } from './util/cron';
+export { Cron };
 export interface ClientConfig extends ImagePath {
     /**
      * Authentication Crowdin App type: "authorization_code", "crowdin_app", "crowdin_agent". Default: "crowdin_app"
@@ -102,6 +108,20 @@ export interface ClientConfig extends ImagePath {
      * config to configure MySQL as a storage
      */
     mysqlConfig?: MySQLStorageConfig;
+    /**
+     * config to configure Cloudflare D1 as a storage
+     */
+    d1Config?: D1StorageConfig;
+    /**
+     * Custom cron for scheduling background jobs.
+     * If not provided, the default node-cron will be used.
+     * Useful for external cron systems like Cloudflare Workers Scheduled Events.
+     */
+    cron?: Cron;
+    /**
+     * Cloudflare Workers Assets configuration
+     */
+    assetsConfig?: AssetsConfig;
     /**
      * integration module logic
      */
@@ -277,13 +297,27 @@ export interface ClientConfig extends ImagePath {
      * Auth guard module for custom authentication/authorization checks
      */
     authGuard?: AuthGuardModule | AuthGuardModule[];
+    /**
+     * custom file storage
+     */
+    fileStore?: FileStore;
+    /**
+     * path to assets files directory (default: 'static')
+     */
+    assetsPath?: string;
+}
+export interface AssetsConfig {
+    /**
+     * Cloudflare Workers Assets Fetcher
+     */
+    fetcher: Fetcher;
 }
 export interface Environments {
     environments?: Environment | Environment[];
 }
 type Environment = 'crowdin' | 'crowdin-enterprise';
 export type Config = ClientConfig & {
-    baseUrl: string;
+    baseUrl?: string;
     clientId: string;
     clientSecret: string;
     port: number;
@@ -408,6 +442,7 @@ export interface CrowdinAppUtilities extends CrowdinMetadataStore {
         extra: Record<string, any>;
     }>;
     storage: Storage;
+    cron: Cron;
 }
 export interface CrowdinMetadataStore {
     saveMetadata: (id: string, metadata: any, crowdinId: string) => Promise<void>;
@@ -522,4 +557,8 @@ export interface ModalModule extends ModuleContent, UiModule, Environments {
 }
 export interface ContextModule extends ContextContent, UiModule, Environments {
 }
-export {};
+export interface FileStore {
+    getFile: (fileRef: string) => Promise<Buffer>;
+    storeFile: (content: Buffer) => Promise<string>;
+    deleteFile: (fileRef: string) => Promise<void>;
+}

package/out/util/axios.js

@@ -19,7 +19,6 @@ class AxiosProvider {
     }
     configureRequest() {
         this.axios.interceptors.request.use((config) => {
-            // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
             return new Promise((resolve) => {
                 const interval = setInterval(() => {
                     if (this.pendingRequests < AxiosProvider.CROWDIN_API_MAX_CONCURRENT_REQUESTS) {

package/out/util/credentials-masker.d.ts

@@ -6,5 +6,5 @@ declare function getRequestCredentialsMasker({ moduleConfig, dataPath, }: {
     moduleConfig?: UiModule;
     dataPath?: string;
 }): (req: Request | CrowdinClientRequest, res: Response, next: Function) => any;
-declare function postRequestCredentialsMasker(moduleConfig?: UiModule, credentialsExtractor?: Function): (req: CrowdinClientRequest | Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, res: Response<any, Record<string, any>>, next: Function) => void;
+declare function postRequestCredentialsMasker(moduleConfig?: UiModule, credentialsExtractor?: Function): (req: Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>> | CrowdinClientRequest, res: Response<any, Record<string, any>>, next: Function) => void;
 export { getRequestCredentialsMasker, postRequestCredentialsMasker, maskKey };

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

@@ -1,16 +1,27 @@
 import { Request, Response } from 'express';
 import { Config, CrowdinClientRequest, ImagePath, UnauthorizedConfig } from '../types';
+export { renderJSX } from './jsx-renderer';
 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 getPreviousDate(days: number): Date;
 export declare function prepareFormDataMetadataId(req: CrowdinClientRequest, config: Config): Promise<string>;
 export declare function validateEmail(email: string | number): boolean;

package/out/util/index.js

@@ -32,12 +32,25 @@ 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.isJson = exports.isAuthorizedConfig = exports.getLogoUrl = exports.executeWithRetry = exports.decryptData = exports.encryptData = exports.runAsyncWrapper = exports.CodeError = void 0;
+exports.getFormattedDate = exports.validateEmail = exports.prepareFormDataMetadataId = exports.getPreviousDate = exports.isDefined = exports.isJson = exports.isAuthorizedConfig = exports.serveLogo = exports.getLogoUrl = exports.executeWithRetry = exports.decryptData = exports.encryptData = exports.runAsyncWrapper = exports.extractBaseUrlFromRequest = exports.CodeError = exports.renderJSX = void 0;
 const crypto = __importStar(require("crypto-js"));
 const storage_1 = require("../storage");
 const types_1 = require("../types");
 const logger_1 = require("./logger");
 const crowdin_apps_functions_1 = require("@crowdin/crowdin-apps-functions");
+const jsx_renderer_1 = require("./jsx-renderer");
+const views_1 = require("../views");
+const static_files_1 = require("./static-files");
+var jsx_renderer_2 = require("./jsx-renderer");
+Object.defineProperty(exports, "renderJSX", { enumerable: true, get: function () { return jsx_renderer_2.renderJSX; } });
+/**
+ * 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 +58,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 +80,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.renderJSX)(views_1.ErrorPage, errorMessage);
+                res.setHeader('Content-Type', 'text/html; charset=utf-8');
+                res.send(html);
             }
             else {
                 res.status(code).send({ error: errorMessage });
@@ -108,13 +129,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;
 }
@@ -129,6 +173,10 @@ function isJson(string) {
     return true;
 }
 exports.isJson = isJson;
+function isDefined(value) {
+    return value !== undefined && value !== null;
+}
+exports.isDefined = isDefined;
 function getPreviousDate(days) {
     const date = new Date();
     date.setDate(date.getDate() - days);

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

@@ -0,0 +1,6 @@
+import type { FC } from 'react';
+/**
+ * Renders a React component to HTML string
+ * Uses React Server-Side Rendering (renderToStaticMarkup)
+ */
+export declare function renderJSX<P = any>(Component: FC<P>, props: P): string;

package/out/util/jsx-renderer.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderJSX = void 0;
+const server_1 = require("react-dom/server");
+/**
+ * Renders a React component to HTML string
+ * Uses React Server-Side Rendering (renderToStaticMarkup)
+ */
+function renderJSX(Component, props) {
+    const element = Component(props);
+    return '<!DOCTYPE html>' + (0, server_1.renderToStaticMarkup)(element);
+}
+exports.renderJSX = renderJSX;

package/out/util/logger.js

@@ -73,9 +73,7 @@ function log(message, context) {
                     project: {
                         id: context.jwtPayload.context.project_id,
                         identifier: (_a = context.jwtPayload.context.project_identifier) !== null && _a !== void 0 ? _a : '',
-                        // eslint-disable-next-line @typescript-eslint/camelcase
                         organization_id: context.jwtPayload.context.organization_id,
-                        // eslint-disable-next-line @typescript-eslint/camelcase
                         user_id: context.jwtPayload.context.user_id,
                     },
                     user: {
@@ -108,9 +106,7 @@ function logError(e, context) {
                 project: {
                     id: context.jwtPayload.context.project_id,
                     identifier: (_a = context.jwtPayload.context.project_identifier) !== null && _a !== void 0 ? _a : '',
-                    // eslint-disable-next-line @typescript-eslint/camelcase
                     organization_id: context.jwtPayload.context.organization_id,
-                    // eslint-disable-next-line @typescript-eslint/camelcase
                     user_id: context.jwtPayload.context.user_id,
                 },
                 user: {

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/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 {};