@carto/ps-utils 0.1.0-alpha.0 → 0.1.0-alpha.3

package/dist/ps-utils.es.js

@@ -23,4 +23,34 @@ function hexToRgbaDeckGL(hexadecimal, alpha = 1) {
   const b = parseInt(hexadecimal.length === 3 ? hexadecimal.slice(2, 3).repeat(2) : hexadecimal.slice(4, 6), 16);
   return [r, g, b, alpha * 255];
 }
-export { hexToRgbaDeckGL };
+function rgbaDeckGLToHex(rgba, { withPrefix = true } = {}) {
+  if (!rgba || !rgba.length) {
+    console.warn(`rgbaDeckGLToHex: invalid array or empty values`);
+    return;
+  }
+  const hasInvalidValue = rgba.some((value) => value < 0 || value > 255);
+  if (hasInvalidValue) {
+    console.warn(`rgbaDeckGLToHex: [${rgba.toString()}] invalid array value format`);
+    return;
+  }
+  const hexadecimal = rgba.map((value) => {
+    const hex = value.toString(16);
+    return hex.padStart(2, "0");
+  }).join("");
+  return `${withPrefix ? "#" : ""}${hexadecimal}`;
+}
+function normalize(data, { format = "NFD", replaceUnicode = "[\u0300-\u036F]" } = {}) {
+  const unicode = new RegExp(replaceUnicode, "g");
+  return data.normalize(format).replace(unicode, "");
+}
+function matchText(text, data, { matchFn, normalizeOptions } = {}) {
+  const regex = new RegExp(normalize(text.toLowerCase(), normalizeOptions), "gi");
+  if (!Array.isArray(data)) {
+    return normalize(data).match(regex) ? data : null;
+  }
+  return data.filter((match) => {
+    const newData = matchFn ? matchFn(match) : match;
+    return normalize(newData).match(regex);
+  });
+}
+export { hexToRgbaDeckGL, matchText, normalize, rgbaDeckGLToHex };

package/dist/ps-utils.umd.js

@@ -1 +1 @@
-(function(n,s){typeof exports=="object"&&typeof module!="undefined"?s(exports):typeof define=="function"&&define.amd?define(["exports"],s):(n=typeof globalThis!="undefined"?globalThis:n||self,s(n.PsUtils={}))})(this,function(n){"use strict";function s(t,o=1){if(!t){console.warn(`hexToRgbaDeckGL: ${t} invalid hexadecimal format`);return}if(o<0||o>1){console.warn(`hexToRgbaDeckGL: ${o} invalid alpha format`);return}if(t!=null&&t.includes("#")&&(t=t.slice(1)),!/[0-9A-Fa-f]{6}/g.test(t)&&!/[0-9A-Fa-f]{3}/g.test(t)&&!/[0-9A-Fa-f]{2}/g.test(t)){console.warn(`hexToRgbaDeckGL: ${t} invalid hexadecimal format`);return}const e=t.length;e<6&&(t=t.slice(0,6-e).repeat(6/e));const r=parseInt(t.length===3?t.slice(0,1).repeat(2):t.slice(0,2),16),f=parseInt(t.length===3?t.slice(1,2).repeat(2):t.slice(2,4),16),u=parseInt(t.length===3?t.slice(2,3).repeat(2):t.slice(4,6),16);return[r,f,u,o*255]}n.hexToRgbaDeckGL=s,Object.defineProperties(n,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})});
+(function(t,i){typeof exports=="object"&&typeof module!="undefined"?i(exports):typeof define=="function"&&define.amd?define(["exports"],i):(t=typeof globalThis!="undefined"?globalThis:t||self,i(t.PsUtils={}))})(this,function(t){"use strict";function i(n,e=1){if(!n){console.warn(`hexToRgbaDeckGL: ${n} invalid hexadecimal format`);return}if(e<0||e>1){console.warn(`hexToRgbaDeckGL: ${e} invalid alpha format`);return}if(n!=null&&n.includes("#")&&(n=n.slice(1)),!/[0-9A-Fa-f]{6}/g.test(n)&&!/[0-9A-Fa-f]{3}/g.test(n)&&!/[0-9A-Fa-f]{2}/g.test(n)){console.warn(`hexToRgbaDeckGL: ${n} invalid hexadecimal format`);return}const r=n.length;r<6&&(n=n.slice(0,6-r).repeat(6/r));const s=parseInt(n.length===3?n.slice(0,1).repeat(2):n.slice(0,2),16),o=parseInt(n.length===3?n.slice(1,2).repeat(2):n.slice(2,4),16),u=parseInt(n.length===3?n.slice(2,3).repeat(2):n.slice(4,6),16);return[s,o,u,e*255]}function c(n,{withPrefix:e=!0}={}){if(!n||!n.length){console.warn("rgbaDeckGLToHex: invalid array or empty values");return}if(n.some(o=>o<0||o>255)){console.warn(`rgbaDeckGLToHex: [${n.toString()}] invalid array value format`);return}const s=n.map(o=>o.toString(16).padStart(2,"0")).join("");return`${e?"#":""}${s}`}function f(n,{format:e="NFD",replaceUnicode:r="[\u0300-\u036F]"}={}){const s=new RegExp(r,"g");return n.normalize(e).replace(s,"")}function g(n,e,{matchFn:r,normalizeOptions:s}={}){const o=new RegExp(f(n.toLowerCase(),s),"gi");return Array.isArray(e)?e.filter(u=>{const l=r?r(u):u;return f(l).match(o)}):f(e).match(o)?e:null}t.hexToRgbaDeckGL=i,t.matchText=g,t.normalize=f,t.rgbaDeckGLToHex=c,Object.defineProperties(t,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})});

package/dist/types/colors/hexToRgbaDeckGL.d.ts

@@ -1,9 +1,11 @@
 /**
- * Function to parse hexadecimal string to deck.gl colors format.
+ * It converts a hexadecimal color to an array of numbers that can be used by Deck.gl
  *
  * @param {string} hexadecimal - hexadecimal string, including # or not
  * @param {number} alpha - opacity of final color, value must be between 0-1
  *
+ * @returns An array of numbers.
+ *
  * @example
  *
  * 6 digits hexadecimal:

package/dist/types/colors/rgbaDeckGLToHex/rgbaDeckGLToHex.d.ts

@@ -0,0 +1,30 @@
+import { RgbaDeckGLToHexOptions } from './types';
+/**
+ * It converts an array of RGBA values to a hexadecimal string.
+ *
+ * @param {number[]} rgba - rgba array, including alpha or not
+ * @param {RgbaDeckGLToHexOptions} options - options to parse
+ *
+ * @returns A string
+ *
+ * @example
+ *
+ * Without alpha value:
+ * ```ts
+ * rgbaDeckGLToHex([0, 0, 0]) // => '#000000'
+ * ```
+ *
+ * With alpha value:
+ * ```ts
+ * rgbaDeckGLToHex([0, 0, 0, 1]) // => '#000000FF'
+ * ```
+ *
+ * Without prefix:
+ * ```ts
+ * rgbaDeckGLToHex([0, 0, 0], { withPrefix: false }) // => '000000'
+ * ```
+ *
+ *
+ * @alpha
+ */
+export declare function rgbaDeckGLToHex(rgba: number[], { withPrefix }?: RgbaDeckGLToHexOptions): string | undefined;

package/dist/types/colors/rgbaDeckGLToHex/types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `RgbaDeckGLToHexOptions` is an object with an optional property `withPrefix` of type
+ * `boolean`.
+ * @property {boolean} withPrefix - boolean - Whether to include the '#' prefix in the hex
+ * string.
+ */
+export declare type RgbaDeckGLToHexOptions = {
+    withPrefix?: boolean;
+};

package/dist/types/index.d.ts

@@ -1 +1,7 @@
 export { hexToRgbaDeckGL } from './colors/hexToRgbaDeckGL';
+export { rgbaDeckGLToHex } from './colors/rgbaDeckGLToHex/rgbaDeckGLToHex';
+export * from './colors/rgbaDeckGLToHex/types';
+export { matchText } from './strings/matchText/matchText';
+export * from './strings/matchText/types';
+export { normalize } from './strings/normalize/normalize';
+export * from './strings/normalize/types';

package/dist/types/strings/matchText/matchText.d.ts

@@ -0,0 +1,13 @@
+import { MatchTextOptions } from './types';
+/**
+ * It takes a string, an array of strings, and an optional object of options, and returns an
+ * array of strings that match the input string
+ * @param {string} text - The text to match against.
+ * @param {T[] | string} data - The data to match against.
+ * @param {MatchTextOptions} options - The options to use.
+ *
+ * @returns {T[] | string | null} - The matched data or null.
+ *
+ * @alpha
+ */
+export declare function matchText<T>(text: string, data: T[] | string, { matchFn, normalizeOptions }?: MatchTextOptions<T>): T[] | string | null;

package/dist/types/strings/matchText/types.d.ts

@@ -0,0 +1,14 @@
+import { NormalizeOptions } from '../normalize/types';
+/**
+ * `MatchTextOptions` is an object with an optional `matchFn` property that is a function
+ * that takes a generic type `T` and returns a string, and an optional `normalizeOptions`
+ * property that is an object with the normalize options.
+ * @property matchFn - A function that takes in the data and returns a string to match
+ * against.
+ * @property {NormalizeOptions} normalizeOptions - This is an object that contains the
+ * options for the normalize function.
+ */
+export declare type MatchTextOptions<T> = {
+    matchFn?: (data: T) => string;
+    normalizeOptions?: NormalizeOptions;
+};

package/dist/types/strings/normalize/normalize.d.ts

@@ -0,0 +1,19 @@
+import { NormalizeOptions } from './types';
+/**
+ * It takes a string and returns a string normalized.
+ * @param {string} data - The data to be normalized.
+ * @param {NormalizeOptions} options  - data - The string to be normalized.
+ * @returns A string
+ *
+ * @remarks
+ * The normalization by default is NFD
+ *
+ * @example
+ *
+ * ```ts
+ * normalize('foo bar')
+ * ```
+ *
+ * @alpha
+ */
+export declare function normalize(data: string, { format, replaceUnicode }?: NormalizeOptions): string;

package/dist/types/strings/normalize/types.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `NormalizeOptions` is an object with optional properties `format` and `replaceUnicode`.
+ *
+ * The `format` property is a string that can be one of four values: `'NFD'`, `'NFKD'`,
+ * `'NFC'`, or `'NFKC'`.
+ *
+ * The `replaceUnicode` property is a string.
+ * @property {'NFD' | 'NFKD' | 'NFC' | 'NFKC'} format - The normalization form to use.
+ * @property {string} replaceUnicode - The unicode character to replace the unicode
+ * characters with. By default is `[\u0300-\u036f]`.
+ */
+export declare type NormalizeOptions = {
+    format?: 'NFD' | 'NFKD' | 'NFC' | 'NFKC';
+    replaceUnicode?: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carto/ps-utils",
-  "version": "0.1.0-alpha.0",
+  "version": "0.1.0-alpha.3",
   "description": "CARTO's Professional Service Utils library",
   "files": [
     "dist"