lupine.api 1.1.63 → 1.1.65

package/README.md

@@ -1,3 +1,122 @@
 # lupine.api
 
-lupine.api is a fast, lightweight, and flexible node.js based server, working with [lupine.web](https://github.com/uuware/lupine.web) to provide SSR and modern JavaScript features for web applications and APIs.
+lupine.api is a fast, lightweight, and flexible node.js based server framework. It is designed to work seamlessly with [lupine.web](https://github.com/uuware/lupine.web) to provide Server-Side Rendering (SSR) and modern API capabilities.
+
+The project consists of two main parts:
+
+1.  **Server (`src/app`)**: A robust HTTP/HTTPS server that manages multiple applications, domains, and processes.
+2.  **API Module (`src/api`)**: A framework for building the backend logic for individual applications.
+
+---
+
+## Server (`src/app`)
+
+The server component is responsible for handling incoming network requests, managing SSL certificates, and dispatching requests to the appropriate application based on domain configuration. It supports clustering logic to utilize multi-core CPUs efficiently.
+
+### Key Features
+
+- **Multi-App & Multi-Domain**: Host multiple independent applications on a single server instance, routing traffic based on domain names.
+- **Cluster Support**: Automatically forks worker processes to match CPU cores for high performance.
+- **SSL/TLS**: Built-in support for HTTPS with custom certificate paths.
+- **Environment Management**: Loads configuration from `.env` files.
+
+### Usage Example
+
+See `apps/server/src/index.ts` for a complete example.
+
+```typescript
+import { appStart, loadEnv, ServerEnvKeys } from 'lupine.api';
+import * as path from 'path';
+
+const initAndStartServer = async () => {
+  // 1. Load Environment Variables
+  await loadEnv('.env');
+
+  // 2. Configure Applications
+  const serverRootPath = path.resolve(process.env[ServerEnvKeys.SERVER_ROOT_PATH]!);
+  const webRootMap = [
+    {
+      appName: 'demo.app',
+      hosts: ['localhost', 'example.com'],
+      // Standard directory structure expected by lupine.api
+      webPath: path.join(serverRootPath, 'demo.app_web'),
+      dataPath: path.join(serverRootPath, 'demo.app_data'),
+      apiPath: path.join(serverRootPath, 'demo.app_api'),
+      dbType: 'sqlite',
+      dbConfig: { filename: 'sqlite3.db' },
+    },
+  ];
+
+  // 3. Start Server
+  await appStart.start({
+    debug: process.env.NODE_ENV === 'development',
+    apiConfig: {
+      serverRoot: serverRootPath,
+      webHostMap: webRootMap,
+    },
+    serverConfig: {
+      httpPort: 8080,
+      httpsPort: 8443,
+      // sslKeyPath: '...',
+      // sslCrtPath: '...',
+    },
+  });
+};
+
+initAndStartServer();
+```
+
+---
+
+## API Module (`src/api`)
+
+The API Module provides the framework for writing the business logic of your application. It acts similarly to Express.js but is optimized for the lupine ecosystem.
+
+### Key Features
+
+- **ApiRouter**: A flexible router supporting GET, POST, and middleware-like filters.
+- **Context Isolation**: Uses `AsyncStorage` to safely manage request-scoped data (like sessions or database transactions) across async operations.
+- **Database Integration**: Built-in helpers for database connections (e.g., SQLite via `better-sqlite3`).
+
+### Usage Example
+
+An application's API entry point (e.g., `apps/demo.app/api/src/index.ts`) typically exports an instance of `ApiModule`.
+
+**1. Entry Point (`index.ts`):**
+
+```typescript
+import { ApiModule } from 'lupine.api';
+import { RootApi } from './service/root-api';
+
+// Export apiModule so the server can load it dynamically
+export const apiModule = new ApiModule(new RootApi());
+```
+
+**2. Root API Service (`service/root-api.ts`):**
+
+```typescript
+import { ApiRouter, IApiBase, IApiRouter } from 'lupine.api';
+
+export class RootApi implements IApiBase {
+  getRouter(): IApiRouter {
+    const router = new ApiRouter();
+
+    // Define routes
+    router.get('/hello', async (req, res) => {
+      res.write(JSON.stringify({ message: 'Hello World' }));
+      res.end();
+      return true; // Return true to indicate request was handled
+    });
+
+    // Sub-routers can be mounted
+    // router.use('/users', new UserApi().getRouter());
+
+    return router;
+  }
+}
+```
+
+### Dashboard
+
+lupine.api includes a built-in extensible dashboard for managing your services.
+Detailed documentation can be found in [README-dashboard.md](README-dashboard.md).

package/dev/index.js

@@ -4,6 +4,7 @@ const fileUtils = require('./file-utils.js');
 const webEnv = require('../src/common-js/web-env.js');
 const { runCmd } = require('./run-cmd.js');
 const { sendRequest } = require('./send-request.js');
+const { markdownProcessOnEnd } = require('./markdown-build.js');
 module.exports = {
   copyFolder,
   cpIndexHtml,
@@ -15,4 +16,5 @@ module.exports = {
   loadEnv: webEnv.loadEnv,
   getWebConfig: webEnv.getWebConfig,
   pluginIfelse: require('./plugin-ifelse.js'),
+  markdownProcessOnEnd,
 };

package/dev/markdown-build.js

@@ -0,0 +1,326 @@
+const fs = require('fs');
+const path = require('path');
+const { marked } = require('marked');
+const matter = require('gray-matter');
+
+const slugify = (text) =>
+  text
+    .toLowerCase()
+    .replace(/[^\w\u4e00-\u9fa5]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+
+const cleanMarkdown = (text) => text.replace(/[`*?^]/g, '');
+
+marked.use({
+  renderer: {
+    heading({ text, depth, raw }) {
+      const id = slugify(raw);
+      // text might contain markdown (e.g. links), so we must parse it inline
+      const content = marked.parseInline(text);
+      return `<h${depth} id="${id}"><a class="header-anchor" href="#${id}">#</a>${content}</h${depth}>`;
+    },
+  },
+});
+
+const builtFiles = new Map(); // path -> { route, importPath, data, headings }
+
+function processFile(filePath, indir, outdir, relativePath) {
+  if (builtFiles.has(filePath)) return builtFiles.get(filePath);
+
+  // Mark as processing to handle potential cycles (though minimal risk with hierarchy)
+  // We'll update the value later.
+  builtFiles.set(filePath, null);
+
+  if (!fs.existsSync(filePath)) {
+    console.warn(`File not found: ${filePath}`);
+    return null;
+  }
+
+  const contentRaw = fs.readFileSync(filePath, 'utf8');
+  const { data, content: markdown } = matter(contentRaw);
+
+  const stat = fs.statSync(filePath);
+  const outHtmlFile = relativePath.replace('.md', '.html');
+  const outPathFile = path.join(outdir, outHtmlFile);
+
+  // Ensure dir exists
+  const outDirName = path.dirname(outPathFile);
+  if (!fs.existsSync(outDirName)) {
+    fs.mkdirSync(outDirName, { recursive: true });
+  }
+
+  // Build HTML if needed
+  if (!fs.existsSync(outPathFile) || stat.mtime > fs.statSync(outPathFile).mtime) {
+    let html = marked.parse(markdown);
+    // Link transformation
+    html = html.replace(/href="([^"]+)"/g, (match, p1) => {
+      if (p1.startsWith('http') || p1.startsWith('#') || p1.startsWith('javascript:')) {
+        return match;
+      }
+      let targetUrl = p1;
+      if (!targetUrl.startsWith('/')) {
+        const currentRouteDir = '/' + path.dirname(relativePath).replace(/\\/g, '/');
+        targetUrl = path.posix.join(currentRouteDir, targetUrl);
+      }
+      return `href="javascript:lpPressLoad('${targetUrl}')"`;
+    });
+    fs.writeFileSync(outPathFile, html);
+  }
+
+  const tokens = marked.lexer(markdown);
+  const headings = [];
+  tokens.forEach((token) => {
+    if (token.type === 'heading' && (token.depth === 2 || token.depth === 3)) {
+      const id = slugify(token.raw);
+      headings.push({ level: token.depth, text: cleanMarkdown(token.text), id });
+    }
+  });
+
+  const lang = relativePath.split(/[\\/]/)[0] || 'en';
+
+  const expandSidebar = (items) => {
+    const result = [];
+    items.forEach((item) => {
+      if (typeof item === 'object' && item.submenu) {
+        let targetPath = item.submenu;
+        if (targetPath.startsWith('/')) targetPath = targetPath.substring(1);
+
+        // submenu points to a directory, look for index.md
+        const subRelative = path.join(targetPath, 'index.md');
+        const subAbs = path.join(indir, subRelative);
+
+        // Recursively build the submenu index
+        const subFileInfo = processFile(subAbs, indir, outdir, subRelative);
+
+        if (subFileInfo && subFileInfo.data && subFileInfo.data.sidebar) {
+          if (subFileInfo.data.title) {
+            result.push({ text: subFileInfo.data.title, items: subFileInfo.data.sidebar });
+          } else {
+            result.push(...subFileInfo.data.sidebar);
+          }
+        } else {
+          // Fallback if no sidebar found, maybe just link to it?
+          // Or ignoring it as per previous logic "find managed files"
+          result.push(item);
+        }
+      } else if (typeof item === 'string') {
+        // Ensure referenced file is built
+        let targetPath = item;
+        if (targetPath.startsWith('/')) targetPath = targetPath.substring(1);
+
+        // It could be a file or a dir (implying index.md)
+        let subAbs = path.join(indir, targetPath);
+        let subRelative = targetPath;
+
+        if (fs.existsSync(subAbs) && fs.statSync(subAbs).isDirectory()) {
+          subRelative = path.join(targetPath, 'index.md');
+          subAbs = path.join(indir, subRelative);
+        } else if (!subAbs.endsWith('.md')) {
+          subAbs += '.md';
+          subRelative += '.md';
+        }
+
+        processFile(subAbs, indir, outdir, subRelative);
+        result.push(item);
+      } else if (typeof item === 'object' && item.items) {
+        item.items = expandSidebar(item.items);
+        result.push(item);
+      } else {
+        result.push(item);
+      }
+    });
+    return result;
+  };
+
+  if (data.sidebar) {
+    data.sidebar = expandSidebar(data.sidebar);
+  }
+
+  const prefixLinks = (obj) => {
+    if (!obj || typeof obj !== 'object') return obj;
+    if (Array.isArray(obj)) return obj.map(prefixLinks);
+    const result = {};
+    for (const key in obj) {
+      let val = obj[key];
+      if (key === 'link' && typeof val === 'string' && val.startsWith('/') && !val.startsWith(`/${lang}/`)) {
+        val = `/${lang}${val}`;
+      }
+      result[key] = prefixLinks(val);
+    }
+    return result;
+  };
+  const prefixedData = prefixLinks(data);
+
+  const route = '/' + relativePath.replace(/\\/g, '/').replace(/\.md$/, '');
+  // const importPath = './' + relativePath.replace(/\\/g, '/').replace(/\.md$/, '.html');
+  const importPath = './' + path.relative(outdir, outPathFile).replace(/\\/g, '/');
+
+  const info = { route, importPath, data: prefixedData, headings };
+  builtFiles.set(filePath, info);
+  return info;
+}
+
+const markdownProcessOnEnd = async (indir, outdir) => {
+  try {
+    if (!indir || !outdir) return;
+
+    const langPath = path.join(indir, 'index.md');
+    if (!fs.existsSync(langPath)) {
+      console.warn(`[dev-markdown] No index.md found in ${indir}`);
+      return;
+    }
+
+    const langContent = fs.readFileSync(langPath, 'utf8');
+    const { data, content: markdown } = matter(langContent);
+    const lang = data.lang;
+    if (!lang || lang.length < 1 || !lang[0].id) {
+      console.warn(`[dev-markdown] No lang found in ${langPath}`);
+      return;
+    }
+
+    // Ensure outDir exists
+    if (!fs.existsSync(outdir)) {
+      fs.mkdirSync(outdir, { recursive: true });
+    }
+
+    builtFiles.clear();
+
+    // Process root index.md to provide global config (languages) at '/'
+    if (fs.existsSync(langPath)) {
+      const rootInfo = processFile(langPath, indir, outdir, 'index.md');
+      if (rootInfo) {
+        rootInfo.route = '/';
+        // Re-key as '/' to ensure it's accessible as markdownConfig['/']
+        builtFiles.delete(langPath);
+        builtFiles.set('/', rootInfo);
+      }
+    }
+
+    lang.forEach((entry) => {
+      const fullPath = path.join(indir, entry.id, 'index.md');
+      if (fs.existsSync(fullPath)) {
+        const relativePath = path.join(entry.id, 'index.md');
+        processFile(fullPath, indir, outdir, relativePath);
+      }
+    });
+
+    // 1. Build a map of route -> data to look up titles
+    const routeMap = new Map();
+    for (const info of builtFiles.values()) {
+      if (info && info.route) {
+        routeMap.set(info.route, info.data);
+      }
+    }
+
+    // 2. Flatten and enrich sidebars for top-level index pages
+    const flattenSidebar = (items, level) => {
+      const result = [];
+      if (!items || !Array.isArray(items)) return result;
+
+      items.forEach((item) => {
+        if (typeof item === 'object' && item.items && Array.isArray(item.items)) {
+          // Group
+          let newLevel = level;
+          if (item.text) {
+            result.push({
+              type: 'group',
+              text: item.text,
+              level: level,
+            });
+            newLevel++;
+          }
+          result.push(...flattenSidebar(item.items, newLevel));
+        } else if (typeof item === 'string') {
+          // Link
+          let link = item;
+          // Ensure link format matches route (usually starts with /)
+          // Look up title
+          const pageData = routeMap.get(link);
+          const text = pageData && pageData.title ? pageData.title : link;
+
+          result.push({
+            type: 'link',
+            text: text, // Enriched title
+            link: link,
+            level: level,
+          });
+        } else if (typeof item === 'object' && item.link) {
+          // Link object already
+          result.push({
+            type: 'link',
+            text: item.text,
+            link: item.link,
+            level: level,
+          });
+        }
+      });
+      return result;
+    };
+
+    // Apply only to index pages (or all pages? usually only index has sidebar)
+    // Actually we should perform this for any file that has a sidebar defined.
+    for (const info of builtFiles.values()) {
+      if (info && info.data && info.data.sidebar) {
+        info.data.sidebar = flattenSidebar(info.data.sidebar, 0);
+      }
+
+      // 3. Process nav
+      const resolveItem = (item) => {
+        let link = typeof item === 'string' ? item : item.link;
+        let text = typeof item === 'string' ? item : item.text;
+
+        if (link) {
+          // Handle directory links (e.g. /zh/guide/ -> /zh/guide/index)
+          // Check if the link exists in routeMap, if not check link + 'index'
+          if (!routeMap.has(link) && routeMap.has(link + '/index')) {
+            link = link + '/index';
+          } else if (!routeMap.has(link) && link.endsWith('/') && routeMap.has(link + 'index')) {
+            link = link + 'index';
+          }
+
+          const pageData = routeMap.get(link);
+          if (!text && pageData && pageData.title) {
+            text = pageData.title;
+          }
+        }
+
+        if (typeof item === 'string') {
+          return { text: text || link, link: link };
+        }
+
+        return { ...item, text: text || link, link: link };
+      };
+
+      for (const info of builtFiles.values()) {
+        if (info && info.data && info.data.nav && Array.isArray(info.data.nav)) {
+          info.data.nav = info.data.nav.map((resolveNav) => resolveItem(resolveNav));
+        }
+      }
+    }
+
+    const files = Array.from(builtFiles.values())
+      .filter((x) => x !== null)
+      .sort((a, b) => a.route.localeCompare(b.route));
+
+    // Generate markdown-config.ts
+    const configPath = path.join(outdir, 'markdown-config.ts');
+    let configContent = files.map((f, i) => `import html${i} from '${f.importPath}';`).join('\n');
+    configContent +=
+      '\n\nexport const markdownConfig: Record<string, { html: string; data: any; headings: any[] }> = {\n';
+    files.forEach((f, i) => {
+      configContent += `  '${f.route}': { html: html${i}, data: ${JSON.stringify(f.data)}, headings: ${JSON.stringify(
+        f.headings
+      )} },\n`;
+    });
+    configContent += '};\n';
+
+    fs.writeFileSync(configPath, configContent);
+    console.log(`[dev-markdown: ${indir}] Successfully built ${files.length} markdown files.`);
+  } catch (err) {
+    console.log(`[dev-markdown: ${indir}] Error:`, err);
+  }
+};
+
+module.exports = {
+  markdownProcessOnEnd,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lupine.api",
-  "version": "1.1.63",
+  "version": "1.1.65",
   "license": "MIT",
   "author": "uuware.com",
   "homepage": "https://github.com/uuware/lupine.js",

package/src/api/server-render.ts

@@ -49,7 +49,9 @@ export const isServerSideRenderUrl = (urlWithoutQuery: string) => {
     ".htpasswd"                   -->   ""
     "name.with.many.dots.myext"   -->   "myext"
   */
-  const ext = urlWithoutQuery.slice(((urlWithoutQuery.lastIndexOf('.') - 1) >>> 0) + 2);
+  // get last section from /
+  const lastSection = urlWithoutQuery.split('/').pop() || '';
+  const ext = lastSection.slice(((lastSection.lastIndexOf('.') - 1) >>> 0) + 2);
   return ext === '' || ext === 'html';
 };
 

package/src/api/static-server.ts

@@ -112,12 +112,12 @@ export class StaticServer {
     } catch (err: any) {
       // file doesn't exist
       if (err.code === 'ENOENT') {
-        if (isServerSideRenderUrl(urlSplit[0])) {
-          serverSideRenderPage(hostPath.appName, hostPath.webPath, urlSplit[0], urlSplit[1], req, res);
-        } else {
-          this.logger.error(`File not found: ${urlSplit[0]}`);
-          handler404(res, `File not found: ${urlSplit[0]}`);
-        }
+        // if (isServerSideRenderUrl(urlSplit[0])) {
+        serverSideRenderPage(hostPath.appName, hostPath.webPath, urlSplit[0], urlSplit[1], req, res);
+        // } else {
+        //   this.logger.error(`File not found: ${urlSplit[0]}`);
+        //   handler404(res, `File not found: ${urlSplit[0]}`);
+        // }
       } else {
         this.logger.error(`Error for: ${urlSplit[0]}`, err);
         handler500(res, `processRequest error: ${err.message}`);

package/src/lib/utils/csv-util.ts

@@ -1,89 +1,89 @@
-import { ServerResponse } from 'http';
-import { Db } from '../db';
-
-export const exportCSVData = async (db: Db, tableName: string, res: ServerResponse) => {
-  res.write(`@TABLE,${tableName}\r\n`);
-
-  const result = await db.selectObject(tableName);
-  if (result && result.length > 0) {
-    const fields = Object.keys(result[0]).join(',').toLowerCase();
-    res.write(`@FIELD,${fields}\r\n`);
-    result.forEach((row: any) => {
-      res.write(`${JSON.stringify(Object.values(row))}\r\n`);
-    });
-  } else {
-    res.write('#no data\r\n');
-  }
-};
-
-export const exportCSVHead = (fileName: string, res: ServerResponse) => {
-  res.writeHead(200, {
-    'Content-Type': 'text/csv',
-    // 'Expires': '0',
-    // 'Cache-Control': 'no-cache, no-store, must-revalidate',
-    'Content-Disposition': 'attachment; filename=' + fileName + '.ljcsv',
-    // 'Content-Description': 'File Transfer',
-  });
-};
-
-export const exportCSV = async (db: Db, tableName: string, res: ServerResponse) => {
-  if (tableName) {
-    exportCSVHead(tableName + '-' + new Date().toJSON().replace(/:/g, '-'), res);
-    await exportCSVData(db, tableName, res);
-  } else {
-    res.writeHead(200, { 'Content-Type': 'text/html' });
-    res.write('Need a table name.');
-  }
-  res.end();
-  return true;
-};
-
-export const loadCSV = async (db: Db, lines: string[]) => {
-  let table = '';
-  let insSql = '';
-  const result: any = {};
-  let toFields: string[] = [];
-  let toFieldsIndex: number[] = [];
-  for (const i in lines) {
-    if (!lines[i] || lines[i].startsWith('#')) {
-      continue;
-    }
-    if (lines[i].startsWith('@TABLE,')) {
-      table = lines[i].substring(7);
-      result[table] = { succeeded: 0, failed: 0, errorMessage: [] };
-
-      const toTableInfo = await db.getTableInfo(table);
-      toFields = toTableInfo.map((item: any) => item.name);
-    } else if (lines[i].startsWith('@FIELD,')) {
-      const allCsvFields = lines[i].substring(7).split(',');
-      const validFields: string[] = [];
-      const validIndices: number[] = [];
-
-      allCsvFields.forEach((field, index) => {
-        if (toFields.includes(field)) {
-          validFields.push(field);
-          validIndices.push(index);
-        }
-      });
-
-      toFieldsIndex = validIndices;
-      const values = Array(validFields.length).fill('?').join(',');
-      insSql = `INSERT INTO ${table} (${validFields.join(',')}) VALUES (${values})`;
-    } else {
-      if (toFields.length === 0 || !insSql) {
-        throw new Error('Invalid CSV format (no @TABLE or @FIELD)');
-      }
-      try {
-        const row = JSON.parse(lines[i]);
-        const values = toFieldsIndex.map((index: number) => row[index]);
-        await db.execute(insSql, values);
-        result[table].succeeded++;
-      } catch (error: any) {
-        result[table].failed++;
-        result[table].errorMessage.push(error.message);
-      }
-    }
-  }
-
-  return result;
-};
+import { ServerResponse } from 'http';
+import { Db } from '../db';
+
+export const exportCSVData = async (db: Db, tableName: string, res: ServerResponse) => {
+  res.write(`@TABLE,${tableName}\r\n`);
+
+  const result = await db.selectObject(tableName);
+  if (result && result.length > 0) {
+    const fields = Object.keys(result[0]).join(',').toLowerCase();
+    res.write(`@FIELD,${fields}\r\n`);
+    result.forEach((row: any) => {
+      res.write(`${JSON.stringify(Object.values(row))}\r\n`);
+    });
+  } else {
+    res.write('#no data\r\n');
+  }
+};
+
+export const exportCSVHead = (fileName: string, res: ServerResponse) => {
+  res.writeHead(200, {
+    'Content-Type': 'text/csv',
+    // 'Expires': '0',
+    // 'Cache-Control': 'no-cache, no-store, must-revalidate',
+    'Content-Disposition': 'attachment; filename=' + fileName + '.ljcsv',
+    // 'Content-Description': 'File Transfer',
+  });
+};
+
+export const exportCSV = async (db: Db, tableName: string, res: ServerResponse) => {
+  if (tableName) {
+    exportCSVHead(tableName + '-' + new Date().toJSON().replace(/:/g, '-'), res);
+    await exportCSVData(db, tableName, res);
+  } else {
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.write('Need a table name.');
+  }
+  res.end();
+  return true;
+};
+
+export const loadCSV = async (db: Db, lines: string[]) => {
+  let table = '';
+  let insSql = '';
+  const result: any = {};
+  let toFields: string[] = [];
+  let toFieldsIndex: number[] = [];
+  for (const i in lines) {
+    if (!lines[i] || lines[i].startsWith('#')) {
+      continue;
+    }
+    if (lines[i].startsWith('@TABLE,')) {
+      table = lines[i].substring(7);
+      result[table] = { succeeded: 0, failed: 0, errorMessage: [] };
+
+      const toTableInfo = await db.getTableInfo(table);
+      toFields = toTableInfo.map((item: any) => item.name);
+    } else if (lines[i].startsWith('@FIELD,')) {
+      const allCsvFields = lines[i].substring(7).split(',');
+      const validFields: string[] = [];
+      const validIndices: number[] = [];
+
+      allCsvFields.forEach((field, index) => {
+        if (toFields.includes(field)) {
+          validFields.push(field);
+          validIndices.push(index);
+        }
+      });
+
+      toFieldsIndex = validIndices;
+      const values = Array(validFields.length).fill('?').join(',');
+      insSql = `INSERT INTO ${table} (${validFields.join(',')}) VALUES (${values})`;
+    } else {
+      if (toFields.length === 0 || !insSql) {
+        throw new Error('Invalid CSV format (no @TABLE or @FIELD)');
+      }
+      try {
+        const row = JSON.parse(lines[i]);
+        const values = toFieldsIndex.map((index: number) => row[index]);
+        await db.execute(insSql, values);
+        result[table].succeeded++;
+      } catch (error: any) {
+        result[table].failed++;
+        result[table].errorMessage.push(error.message);
+      }
+    }
+  }
+
+  return result;
+};