@opengis/gis 0.2.185 → 0.2.187

package/server/routes/map/functions/gis.icon.js

@@ -1,13 +1,21 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import { existsSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 
 import * as solidIcons from '@fortawesome/free-solid-svg-icons';
 import sharp from 'sharp';
+import pathBounds from 'svg-path-bounds';
+import { openSync } from 'fontkit';
+
 import { BadRequestError, NotFoundError } from '@opengis/fastify-table/errors.js';
 
-const iconFilenamePattern = /^([a-z][a-z0-9]*)-(s|m|l|xl)-(fa|ar)-([\p{L}\p{N}-]+)\+([a-f0-9]{3,8})\.(png|svg)$/iu;
+import fonts from '../fonts/index.js';
+
+const iconFilenamePattern = /^([a-z][a-z0-9]*)-(sm|s|m|l|xl)-(fa|ar|ab|ty|mi|gl|ma|mn)-([\p{L}\p{N}_-]+)\+([a-z]+|[a-f0-9]{3,8})\.(png|svg)$/iu;
+
 const validColorLengths = new Set([3, 4, 6, 8]);
+const validColors = new Set(['red', 'green', 'black', 'gray', 'yellow', 'white', 'blue', 'orange', 'purple', 'pink', 'brown']);
 
 const iconSizeByCode = {
   s: 24,
@@ -57,31 +65,75 @@ function parseIconFilename(filename) {
   const match = iconFilenamePattern.exec(filename);
   if (!match) return null;
 
-  const [, pinName, sizeCode, iconType, iconValue, hexColor, format] = match;
-  if (!validColorLengths.has(hexColor.length)) return null;
+  const [, pinName, sizeCode, iconType, iconValue, colorEl, format] = match;
+  const isHexColor = colorEl && /[a-f0-9]{3,8}/.test(colorEl.toLowerCase()); // hex or plain text
+  if (isHexColor && !validColorLengths.has(colorEl.length)) return null;
+  if (!isHexColor && !validColors.has(colorEl)) return null;
+
+  const iconFont = iconType.toLowerCase();
+
+  const iconValue1 = iconFont === 'fa'
+    ? iconValue.toLowerCase()
+    : iconValue.toUpperCase();
 
   return {
     filename: filename.toLowerCase(),
     pinName: pinName.toLowerCase(),
     size: iconSizeByCode[sizeCode.toLowerCase()],
-    iconType: iconType.toLowerCase(),
-    iconValue: iconType.toLowerCase() === 'fa'
-      ? iconValue.toLowerCase()
-      : iconValue.toUpperCase(),
-    color: `#${hexColor}`,
+    iconType: iconFont,
+    iconValue: iconValue1,
+    color: isHexColor ? `#${colorEl}` : colorEl,
     format: format.toLowerCase(),
   };
 }
 
-function findIcon(iconName) {
+const test = {};
+
+function findIcon(iconName, iconFont) {
   const exportName = `fa${iconName.replace(/(^|-)([a-z0-9])/g, (_, __, char) => char.toUpperCase())}`;
   const exportedIcon = solidIcons[exportName];
 
   if (exportedIcon?.prefix === 'fas') return exportedIcon;
 
-  return Object.values(solidIcons).find(icon => (
+  const icon1 = Object.values(solidIcons).find(icon => (
     icon?.prefix === 'fas' && icon.iconName === iconName
   ));
+
+  if (icon1) return icon1;
+
+  const { ar, font: fontName } = fonts[iconFont] || {};
+  const iconCode = fonts[iconFont].ar?.[iconName.toLowerCase()];
+
+  if (!fontName || !iconCode || !ar?.[iconName.toLowerCase()]) {
+    return null;
+  }
+
+  const dirname = path.dirname(fileURLToPath(import.meta.url));
+  if (process.platform === 'win32') test[fontName] = 1;
+  const fontPath = path.join(dirname, `../fonts/${fontName}`);
+
+  if (!existsSync(fontPath)) {
+    return null;
+  }
+
+  const font = openSync(fontPath);
+  const unicodePoint = Number.parseInt(iconCode, 16);
+  const glyph = font.glyphForCodePoint(unicodePoint);
+
+  const { minX, minY, maxX, maxY } = glyph.bbox;
+
+  return {
+    prefix: font,
+    iconName: iconName.toLowerCase(),
+    icon: [
+      maxX - minX,
+      maxY - minY,
+      iconName.toLowerCase(),
+      99,
+      glyph.path.toSVG(),
+    ],
+    bbox: glyph.bbox,
+  };
 }
 
 async function readFileIfExists(filePath, encoding) {
@@ -107,30 +159,66 @@ function getPinPlacement(pinName, width, height) {
   };
 }
 
-function createFontAwesomeSvg(icon, placement, color) {
-  const [width, height, , , pathData] = icon.icon;
-  const paths = Array.isArray(pathData) ? pathData : [pathData];
-  const x = placement.x - placement.iconSize / 2;
-  const y = placement.y - placement.iconSize / 2;
-
-  return `<svg data-gis-icon-layer="foreground" x="${x}" y="${y}" width="${placement.iconSize}" height="${placement.iconSize}" viewBox="0 0 ${width} ${height}" fill="${color}">
-      ${paths.map(iconPath => `<path d="${iconPath}"/>`).join('')}
-    </svg>`;
-}
-
 function createSymbolSvg(symbol, placement, color) {
   const fontSize = Math.round(placement.iconSize * 0.75);
 
   return `<text data-gis-icon-layer="foreground" x="${placement.x}" y="${placement.y}" fill="${color}" font-family="Arial, sans-serif" font-size="${fontSize}" font-weight="700" text-anchor="middle" dominant-baseline="middle">${symbol}</text>`;
 }
 
+function createFontIconSvg(icon, placement, color) {
+  const [, , , , pathData] = icon.icon;
+  const paths = Array.isArray(pathData) ? pathData : [pathData];
+
+  const bounds = paths.reduce(
+    (result, path) => {
+      const [minX, minY, maxX, maxY] = pathBounds(path);
+
+      return {
+        minX: Math.min(result.minX, minX),
+        minY: Math.min(result.minY, minY),
+        maxX: Math.max(result.maxX, maxX),
+        maxY: Math.max(result.maxY, maxY),
+      };
+    },
+    {
+      minX: Infinity,
+      minY: Infinity,
+      maxX: -Infinity,
+      maxY: -Infinity,
+    },
+  );
+
+  const width = bounds.maxX - bounds.minX;
+  const height = bounds.maxY - bounds.minY;
+
+  const scale = placement.iconSize / Math.max(width, height);
+
+  const centerX = (bounds.minX + bounds.maxX) / 2;
+  const centerY = (bounds.minY + bounds.maxY) / 2;
+
+  return `<g
+    data-gis-icon-layer="foreground"
+    transform="
+      translate(${placement.x} ${placement.y})
+      scale(${scale} ${-scale})
+      translate(${-centerX} ${-centerY})
+    "
+    fill="${color}"
+  >
+    ${paths.map(path => `<path d="${path}"/>`).join('')}
+  </g>`;
+}
+
 function createForegroundSvg(options, placement) {
-  if (options.iconType === 'ar') {
+  if (options.iconValue && options.iconValue.length === 1) {
     return createSymbolSvg(options.iconValue, placement, options.color);
   }
 
-  const icon = findIcon(options.iconValue);
-  return icon ? createFontAwesomeSvg(icon, placement, options.color) : null;
+  const icon = findIcon(options.iconValue, options.iconType);
+
+  return icon
+    ? createFontIconSvg(icon, placement, options.color)
+    : null;
 }
 
 function setSvgViewport(svg, size, width, height) {
@@ -152,19 +240,36 @@ async function createPinSvg({
 }) {
   const templatePath = path.join(pinDirectory, `${pinName}.svg`);
   const template = await readFileIfExists(templatePath, 'utf8');
+
   if (!template) return null;
 
   const width = getSvgAttribute(template, 'width', 512);
   const height = getSvgAttribute(template, 'height', 512);
+
   const placement = getPinPlacement(pinName, width, height);
+
   const coloredTemplate = placement.recolorBackground
     ? template.replace(/#ff0000/gi, color)
     : template;
-  const svg = setSvgViewport(coloredTemplate, size, width, height);
-  const foreground = createForegroundSvg({ ...iconOptions, color }, placement);
+
+  const svg = setSvgViewport(
+    coloredTemplate,
+    size,
+    width,
+    height
+  );
+
+  const foreground = createForegroundSvg(
+    { ...iconOptions, color },
+    placement,
+  );
+
   if (!foreground) return null;
 
-  return svg.replace(/<\/svg>\s*$/, `${foreground}</svg>`);
+  return svg.replace(
+    /<\/svg>\s*$/i,
+    `${foreground}</svg>`
+  );
 }
 
 async function createIcon(options) {
@@ -204,7 +309,8 @@ export default async function gisIconApi({ name, nocache }) {
     throw BadRequestError('invalid icon name');
   }
 
-  const image = await getIcon(options, nocache);
+  // fixed icon size of 32px
+  const image = await getIcon({ ...options, size: 32 }, nocache);
 
   if (!image) {
     throw NotFoundError('icon not found');

package/server/routes/map/map.route.js

@@ -149,6 +149,9 @@ export default function route(app) {
                 sql: query.sql,
                 pointZoom: query.pointZoom,
             }, pg);
+            if (process.platform === 'win32' && typeof result === 'string') {
+                return result;
+            }
             return reply.headers(result.headers).send(result.data);
         });
     }

package/server/routes/map/map.route.test.js

@@ -56,6 +56,7 @@ describe('map api test', () => {
         const res = await injectWithHeaders({
             method: 'GET',
             url: `/api/gis-icon/pin6-m-fa-plus-square+7ed957.png`,
+            query: { nocache: 1 },
             headers: { uid: user.id, user_type: user.type }
         });
         expect(res.statusCode).toBe(200);
@@ -67,6 +68,7 @@ describe('map api test', () => {
         const res = await injectWithHeaders({
             method: 'GET',
             url: `/api/icon/pin6-m-fa-plus-square+7ed957.png`,
+            query: { nocache: 1 },
             headers: { uid: user.id, user_type: user.type }
         });
         expect(res.statusCode).toBe(200);
@@ -78,6 +80,7 @@ describe('map api test', () => {
         const res = await injectWithHeaders({
             method: 'GET',
             url: `/api/gis-icon/pin6-m-fa-plus-square+7ed957.svg`,
+            query: { nocache: 1 },
             headers: { uid: user.id, user_type: user.type }
         });
         expect(res.statusCode).toBe(200);
@@ -90,6 +93,7 @@ describe('map api test', () => {
         const res = await injectWithHeaders({
             method: 'GET',
             url: `/api/gis-icon/pin6-m-ar-E+ff4500.svg`,
+            query: { nocache: 1 },
             headers: { uid: user.id, user_type: user.type }
         });
         expect(res.statusCode).toBe(200);
@@ -105,6 +109,7 @@ describe('map api test', () => {
             const res = await injectWithHeaders({
                 method: 'GET',
                 url: `/api/gis-icon/${pin}-m-fa-plus-square+7ed957.svg`,
+                query: { nocache: 1 },
                 headers: { uid: user.id, user_type: user.type }
             });
             expect(res.statusCode).toBe(200);
@@ -127,6 +132,7 @@ describe('map api test', () => {
             const res = await injectWithHeaders({
                 method: 'GET',
                 url: `/api/gis-icon/${pin}-m-fa-plus-square+7ed957.svg`,
+                query: { nocache: 1 },
                 headers: { uid: user.id, user_type: user.type }
             });
             expect(res.statusCode).toBe(200);
@@ -137,6 +143,190 @@ describe('map api test', () => {
         },
     );
 
+    test('GET /gis-icon with typicons font (ty)', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-icon/pin-m-ty-anchor+ff0000.svg`,
+            query: { nocache: 1 },
+            headers: { uid: user.id, user_type: user.type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('image/svg+xml');
+        expect(res.body).toContain('<svg');
+        expect(res.body).toContain('fill="#ff0000"');
+    });
+
+    test('GET /gis-icon with maki font (ma)', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-icon/pin-m-ma-zoo+00ff00.svg`,
+            query: { nocache: 1 },
+            headers: { uid: user.id, user_type: user.type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('image/svg+xml');
+        expect(res.body).toContain('<svg');
+        expect(res.body).toContain('fill="#00ff00"');
+    });
+
+    test('GET /gis-icon with fontawesome font (fa)', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-icon/pin-m-fa-heart+ff0000.svg`,
+            query: { nocache: 1 },
+            headers: { uid: user.id, user_type: user.type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('image/svg+xml');
+        expect(res.body).toContain('<svg');
+        expect(res.body).toContain('fill="#ff0000"');
+    });
+
+    test('GET /gis-icon with map icons font (mi)', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-icon/pin-m-mi-hospital+0000ff.svg`,
+            query: { nocache: 1 },
+            headers: { uid: user.id, user_type: user.type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('image/svg+xml');
+        expect(res.body).toContain('<svg');
+        expect(res.body).toContain('fill="#0000ff"');
+    });
+
+    test('GET /gis-icon with glyphicons font (gl)', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-icon/pin-m-gl-heart+ffff00.svg`,
+            query: { nocache: 1 },
+            headers: { uid: user.id, user_type: user.type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('image/svg+xml');
+        expect(res.body).toContain('<svg');
+        expect(res.body).toContain('fill="#ffff00"');
+    });
+
+    test('GET /gis-icon with mongolia font (mn)', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-icon/pin-m-mn-book+ffa500.svg`,
+            query: { nocache: 1 },
+            headers: { uid: user.id, user_type: user.type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('image/svg+xml');
+        expect(res.body).toContain('<svg');
+        expect(res.body).toContain('fill="#ffa500"');
+    });
+
+    // Test different pin types with various fonts
+    test.each([
+        ['ty', 'anchor'],
+        ['ma', 'zoo'],
+        ['fa', 'heart'],
+        ['mi', 'hospital'],
+        ['gl', 'heart'],
+        ['mn', 'book']
+    ])('GET /gis-icon with different pins and %s font', async (fontType, icon) => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-icon/pin2-m-${fontType}-${icon}+7ed957.svg`,
+            query: { nocache: 1 },
+            headers: { uid: user.id, user_type: user.type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('image/svg+xml');
+        expect(res.body).toContain('<svg');
+        expect(res.body).toContain('fill="#7ed957"');
+    });
+
+    // Test different sizes
+    test.each(['s', 'm', 'l', 'xl'])('GET /gis-icon with different sizes (%s)', async (size) => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-icon/pin-${size}-fa-star+red.svg`,
+            query: { nocache: 1 },
+            headers: { uid: user.id, user_type: user.type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('image/svg+xml');
+        expect(res.body).toContain('<svg');
+    });
+
+    // Test PNG format
+    test('GET /gis-icon with PNG format', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-icon/pin-m-fa-star+blue.png`,
+            query: { nocache: 1 },
+            headers: { uid: user.id, user_type: user.type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('image/png');
+        expect(res.body.includes('PNG')).toBeTruthy();
+    });
+
+    // Test hex color formats
+    test.each([
+        ['3-digit hex', 'f00'],
+        ['4-digit hex', 'f00f'],
+        ['6-digit hex', 'ff0000'],
+        ['8-digit hex', 'ff0000ff']
+    ])('GET /gis-icon with %s color', async (format, color) => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-icon/pin-m-fa-star+${color}.svg`,
+            query: { nocache: 1 },
+            headers: { uid: user.id, user_type: user.type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('image/svg+xml');
+        expect(res.body).toContain('<svg');
+    });
+
+    // Test named colors
+    test.each([
+        'red', 'green', 'black', 'gray', 'yellow', 'white', 'blue', 'orange', 'purple', 'pink', 'brown'
+    ])('GET /gis-icon with named color %s', async (color) => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-icon/pin-m-fa-star+${color}.svg`,
+            query: { nocache: 1 },
+            headers: { uid: user.id, user_type: user.type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('image/svg+xml');
+        expect(res.body).toContain('<svg');
+    });
+
+    // Test invalid icon name returns 400
+    test('GET /gis-icon with invalid name returns 400', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-icon/invalid-name.svg`,
+            query: { nocache: 1 },
+            headers: { uid: user.id, user_type: user.type }
+        });
+        expect(res.statusCode).toBe(400);
+        expect(res.json()).toHaveProperty('message');
+        expect(res.json().message).toContain('invalid icon name');
+    });
+
+    // Test icon not found returns 404
+    test('GET /gis-icon with non-existent icon returns 404', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-icon/pin-m-fa-nonexistenticon+red.svg`,
+            query: { nocache: 1 },
+            headers: { uid: user.id, user_type: user.type }
+        });
+        expect(res.statusCode).toBe(404);
+        expect(res.json()).toHaveProperty('message');
+        expect(res.json().message).toContain('icon not found');
+    });
+
     test('GET /maps', async () => {
         const res = await injectWithHeaders({
             method: 'GET', url: `/api/maps`,

package/server/routes/registers/functions/getTableColumnMeta.js

@@ -88,11 +88,11 @@ export default async function getTableColumnMeta(
             ? `with c(id,text) as (select id, id as text from (select unnest("${queryColumn.replace(
                 /"/g,
                 ""
-            )}") as id from ${tableName} t ${sqlTable})q group by id) select id, text from c`
+            )}"::text[]) as id from ${tableName} t ${sqlTable})q group by id) select id, text from c`
             : `with c(id,text) as (select id, id as text, count(*) from (select unnest("${queryColumn.replace(
                 /"/g,
                 ""
-            )}") as id from ${tableName} t ${sqlTable})q group by id limit ${defaultLimit}) select * from c`;
+            )}"::text[]) as id from ${tableName} t ${sqlTable})q group by id limit ${defaultLimit}) select * from c`;
 
         return {
             arr,
@@ -103,17 +103,17 @@ export default async function getTableColumnMeta(
     }
 
     const original = filtered
-        ? `with c(id,text) as (select rtrim( replace( replace( replace( encode("${queryColumn.replace(/"/g, '')}"::bytea, 'base64'), '+', '' ), '-', '' ), '/', '' ), '=' ) as id, "${queryColumn.replace(
+        ? `with c(id,text) as (select rtrim( replace( replace( replace( encode("${queryColumn.replace(/"/g, '')}"::text::bytea, 'base64'), '+', '' ), '-', '' ), '/', '' ), '=' ) as id, "${queryColumn.replace(
             /"/g,
             ""
-        )}" as text from ${tableName} t ${sqlTable} group by "${queryColumn.replace(
+        )}"::text as text from ${tableName} t ${sqlTable} group by "${queryColumn.replace(
             /"/g,
             ""
         )}") select id, text from c`
-        : `with c(id,text) as (select rtrim( replace( replace( replace( encode("${queryColumn.replace(/"/g, '')}"::bytea, 'base64'), '+', '' ), '-', '' ), '/', '' ), '=' ) as id, "${queryColumn.replace(
+        : `with c(id,text) as (select rtrim( replace( replace( replace( encode("${queryColumn.replace(/"/g, '')}"::text::bytea, 'base64'), '+', '' ), '-', '' ), '/', '' ), '=' ) as id, "${queryColumn.replace(
             /"/g,
             ""
-        )}" as text, count(*) from ${tableName} t ${sqlTable} group by "${queryColumn.replace(
+        )}"::text as text, count(*) from ${tableName} t ${sqlTable} group by "${queryColumn.replace(
             /"/g,
             ""
         )}" limit ${defaultLimit}) select * from c`;

package/server/routes/registers/functions/gis.suggest.js

@@ -83,12 +83,12 @@ export default async function gisSuggest({ token, key, val, uid, lang = 'ua', li
     if (arr && !cls) {
         const sqlCls = count
             ? `select value, count(*) from (select ${pg.pgType?.[dataTypeID]?.includes("[]")
-                ? `unnest("${name}")`
-                : `"${name}"`
+                ? `unnest("${name}"::text[])`
+                : `"${name}"::text`
             } as value from ${table} where 1=1)q group by value`
             : `select array_agg(distinct value)::text[] from (select ${pg.pgType?.[dataTypeID]?.includes("[]")
-                ? `unnest("${name}")`
-                : `"${name}"`
+                ? `unnest("${name}"::text[])`
+                : `"${name}"::text`
             } as value from ${table} where 1=1)q`;
 
         if (pg?.pk?.[registry.table_name] && !cls) {
@@ -184,8 +184,8 @@ export default async function gisSuggest({ token, key, val, uid, lang = 'ua', li
             "''"
         )} o 
             WHERE ${pg.pgType[dataTypeID]?.includes("[]")
-            ? `c.text = ANY(o."${name}")`
-            : `o."${name}" IS NOT DISTINCT FROM c.text`
+            ? `c.text = ANY(o."${name}"::text)`
+            : `o."${name}"::text IS NOT DISTINCT FROM c.text`
         } ) and ${whereQuery || "true"}
           ${order} LIMIT $${args.length}::bigint`
         : `with c(id,text) as ( ${clsMeta.original} where ${whereQuery} ${order}) select * from c LIMIT $${args.length}::bigint`;