@carto/ps-utils 0.1.0-alpha.1 → 0.1.0-alpha.10

package/dist/ps-utils.es.js

@@ -1,26 +1,47 @@
-function hexToRgbaDeckGL(hexadecimal, alpha = 1) {
-  if (!hexadecimal) {
-    console.warn(`hexToRgbaDeckGL: ${hexadecimal} invalid hexadecimal format`);
+function f(n, r = 1) {
+  if (!n) {
+    console.warn(`hexToRgbaDeckGL: ${n} invalid hexadecimal format`);
     return;
   }
-  if (alpha < 0 || alpha > 1) {
-    console.warn(`hexToRgbaDeckGL: ${alpha} invalid alpha format`);
+  if (r < 0 || r > 1) {
+    console.warn(`hexToRgbaDeckGL: ${r} invalid alpha format`);
     return;
   }
-  if (hexadecimal == null ? void 0 : hexadecimal.includes("#")) {
-    hexadecimal = hexadecimal.slice(1);
+  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;
   }
-  if (!/[0-9A-Fa-f]{6}/g.test(hexadecimal) && !/[0-9A-Fa-f]{3}/g.test(hexadecimal) && !/[0-9A-Fa-f]{2}/g.test(hexadecimal)) {
-    console.warn(`hexToRgbaDeckGL: ${hexadecimal} invalid hexadecimal format`);
+  const t = n.length;
+  t < 6 && (n = n.slice(0, 6 - t).repeat(6 / t));
+  const e = 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), s = parseInt(n.length === 3 ? n.slice(2, 3).repeat(2) : n.slice(4, 6), 16);
+  return [e, o, s, r * 255];
+}
+function g(n, { withPrefix: r = !0 } = {}) {
+  if (!n || !n.length) {
+    console.warn("rgbaDeckGLToHex: invalid array or empty values");
     return;
   }
-  const length = hexadecimal.length;
-  if (length < 6) {
-    hexadecimal = hexadecimal.slice(0, 6 - length).repeat(6 / length);
+  if (n.some((o) => o < 0 || o > 255)) {
+    console.warn(`rgbaDeckGLToHex: [${n.toString()}] invalid array value format`);
+    return;
   }
-  const r = parseInt(hexadecimal.length === 3 ? hexadecimal.slice(0, 1).repeat(2) : hexadecimal.slice(0, 2), 16);
-  const g = parseInt(hexadecimal.length === 3 ? hexadecimal.slice(1, 2).repeat(2) : hexadecimal.slice(2, 4), 16);
-  const b = parseInt(hexadecimal.length === 3 ? hexadecimal.slice(2, 3).repeat(2) : hexadecimal.slice(4, 6), 16);
-  return [r, g, b, alpha * 255];
+  const e = n.map((o) => o.toString(16).padStart(2, "0")).join("");
+  return `${r ? "#" : ""}${e}`;
+}
+function u(n, { format: r = "NFD", replaceUnicode: t = "[\u0300-\u036F]" } = {}) {
+  const e = new RegExp(t, "g");
+  return n.normalize(r).replace(e, "");
+}
+function c(n, r, { matchFn: t, normalizeOptions: e } = {}) {
+  const o = new RegExp(u(n.toLowerCase(), e), "gi");
+  return Array.isArray(r) ? r.filter((s) => {
+    const i = t ? t(s) : s;
+    return u(i).match(o);
+  }) : u(r).match(o) ? r : null;
 }
-export { hexToRgbaDeckGL };
+export {
+  f as hexToRgbaDeckGL,
+  c as matchText,
+  u as normalize,
+  g as 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<"u"?i(exports):typeof define=="function"&&define.amd?define(["exports"],i):(t=typeof globalThis<"u"?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.1",
+  "version": "0.1.0-alpha.10",
   "description": "CARTO's Professional Service Utils library",
   "files": [
     "dist"
@@ -16,12 +16,13 @@
     }
   },
   "scripts": {
-    "build": "vite build && mv dist/src dist/types",
+    "build": "vite build",
     "lint": "eslint './**/*.{ts,tsx}' --ignore-path ../../.gitignore",
     "format": "prettier --write . --ignore-path ../../.gitignore",
     "docs:generate": "typedoc --options ../../typedoc.json src/index.ts",
     "test:watch": "vitest",
-    "test:coverage": "vitest --coverage"
+    "test:related": "vitest --run --passWithNoTests",
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {}
 }