@design-edito/tools 0.0.30 → 0.0.32

package/chunks/chunk-KNE7WIIW.js

@@ -0,0 +1 @@
+function e(n,r){return typeof r=="string"?n===r:n.match(r)!==null}function g(n,r){return Array.isArray(r)?r.some(t=>e(n,t)):e(n,r)}function i(n,r){return Array.isArray(r)?r.every(t=>e(n,t)):e(n,r)}export{e as a,g as b,i as c};

package/index.js

@@ -1,13 +1,14 @@
 import * as Comp from './components/Comp/index.js'
 import * as absoluteModulo from './utils/agnostic/absolute-modulo/index.js'
-import * as arrayRandomPick from './utils/agnostic/array-random-pick/index.js'
+import * as array from './utils/agnostic/array/index.js'
+import * as assert from './utils/agnostic/assert/index.js'
+import * as awaitTimeout from './utils/agnostic/await-timeout/index.js'
 import * as bem from './utils/agnostic/bem/index.js'
 import * as cast from './utils/agnostic/cast/index.js'
 import * as charcodeString from './utils/agnostic/charcode-string/index.js'
 import * as clamp from './utils/agnostic/clamp/index.js'
 import * as clientsideHtmlSanitizer from './utils/agnostic/clientside-html-sanitizer/index.js'
 import * as crossenv from './utils/agnostic/crossenv/index.js'
-import * as findDuplicatesInArray from './utils/agnostic/find-duplicates-in-array/index.js'
 import * as flattenGetters from './utils/agnostic/flatten-getters/index.js'
 import * as generateHtmlPlaceholders from './utils/agnostic/generate-html-placeholders/index.js'
 import * as generateNiceColor from './utils/agnostic/generate-nice-color/index.js'
@@ -23,15 +24,18 @@ import * as isRecord from './utils/agnostic/is-record/index.js'
 import * as isValidCssClassName from './utils/agnostic/is-valid-css-class-name/index.js'
 import * as memoize from './utils/agnostic/memoize/index.js'
 import * as objectValidateFromPartial from './utils/agnostic/object-validate-from-partial/index.js'
-import * as randomUuid from './utils/agnostic/random-uuid/index.js'
+import * as random from './utils/agnostic/random/index.js'
 import * as recordFormat from './utils/agnostic/record-format/index.js'
+import * as regexp from './utils/agnostic/regexp/index.js'
 import * as replaceAll from './utils/agnostic/replace-all/index.js'
 import * as responsiveHarmonics from './utils/agnostic/responsive-harmonics/index.js'
 import * as roundNumbers from './utils/agnostic/round-numbers/index.js'
 import * as selectorToElement from './utils/agnostic/selector-to-element/index.js'
 import * as silentLog from './utils/agnostic/silent-log/index.js'
 import * as strToNodes from './utils/agnostic/str-to-nodes/index.js'
+import * as stringMatches from './utils/agnostic/string-matches/index.js'
 import * as throttleDebounce from './utils/agnostic/throttle-debounce/index.js'
+import * as toAlphanum from './utils/agnostic/to-alphanum/index.js'
 import * as transition from './utils/agnostic/transition/index.js'
 import * as wait from './utils/agnostic/wait/index.js'
 import * as dynamicCss from './utils/browser/dynamic-css/index.js'
@@ -43,14 +47,15 @@ import * as processExit from './utils/node/process-exit/index.js'
 import * as readWriteFile from './utils/node/read-write-file/index.js'
 export { Comp }
 export { absoluteModulo }
-export { arrayRandomPick }
+export { array }
+export { assert }
+export { awaitTimeout }
 export { bem }
 export { cast }
 export { charcodeString }
 export { clamp }
 export { clientsideHtmlSanitizer }
 export { crossenv }
-export { findDuplicatesInArray }
 export { flattenGetters }
 export { generateHtmlPlaceholders }
 export { generateNiceColor }
@@ -66,15 +71,18 @@ export { isRecord }
 export { isValidCssClassName }
 export { memoize }
 export { objectValidateFromPartial }
-export { randomUuid }
+export { random }
 export { recordFormat }
+export { regexp }
 export { replaceAll }
 export { responsiveHarmonics }
 export { roundNumbers }
 export { selectorToElement }
 export { silentLog }
 export { strToNodes }
+export { stringMatches }
 export { throttleDebounce }
+export { toAlphanum }
 export { transition }
 export { wait }
 export { dynamicCss }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@design-edito/tools",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "description": "",
   "author": "Maxime Fabas",
   "license": "ISC",

package/utils/agnostic/array/index.d.ts

@@ -0,0 +1,7 @@
+type Filler<T = any> = (pos?: number) => T;
+export declare function make<T>(filler: Filler<T>, length: number): T[];
+export declare function findDuplicates<T>(arr: T[], stopAtFirst?: boolean): T[];
+export declare const randomPickErrorSybol: unique symbol;
+export type RandomPickErrorSymbol = typeof randomPickErrorSybol;
+export default function randomPick<T>(arr: T[], exclude?: T[]): T | RandomPickErrorSymbol;
+export {};

package/utils/agnostic/array/index.js

@@ -0,0 +1 @@
+function f(e,t){return new Array(t).fill(null).map((r,o)=>e(o))}function s(e,t=!1){let r=new Set,o=new Set;for(let n of e){if(r.has(n)&&t)return[n];r.has(n)&&o.add(n),r.add(n)}return Array.from(o)}var a=Symbol();function i(e,t=[]){let r=[...e].filter(l=>!t.includes(l)),o=r.length;if(o===0)return a;let n=Math.floor(Math.random()*o);return r[n]}export{i as default,s as findDuplicates,f as make,a as randomPickErrorSybol};

package/utils/agnostic/assert/index.d.ts

@@ -0,0 +1,3 @@
+type Assertion = (() => boolean) | boolean;
+export default function assert(label: string, assertion: Assertion | Array<Assertion>): void;
+export {};

package/utils/agnostic/assert/index.js

@@ -0,0 +1 @@
+function o(e){console.info(`\u2705 SUCCESS: "${e}"`)}function n(e){throw new Error(`\u{1F6AB} FAILURE: "${e}""`)}function s(e,r){if(Array.isArray(r))r.forEach((t,f)=>s(`${e} (${f})`,t));else if(typeof r=="function")try{r()===!1?n(e):o(e)}catch(t){n(`${t}`)}else r===!1?n(e):o(e)}export{s as default};

package/utils/agnostic/await-timeout/index.d.ts

@@ -0,0 +1,2 @@
+export type Callback<T> = () => T;
+export default function awaitTimeout<T extends any>(callback: Callback<T>, timeoutMs: number): Promise<unknown>;

package/utils/agnostic/await-timeout/index.js

@@ -0,0 +1 @@
+function o(e,t){return new Promise(async(a,n)=>{let c=setTimeout(()=>n(!1),t),l=await e();return clearTimeout(c),a(l)})}export{o as default};

package/utils/agnostic/random/index.d.ts

@@ -0,0 +1,9 @@
+export declare function random(bound1?: number): number | undefined;
+export declare function random(bound1?: number, bound2?: number | undefined): number | undefined;
+export default random;
+export declare function randomInt(...args: Parameters<typeof random>): number | undefined;
+export declare const hexChars: string[];
+export declare function randomHexChar(): string;
+export declare function randomHash(length?: number): string;
+export declare function randomHashPattern(pattern: number[], joiner?: string): string;
+export declare function randomUUID(): string;

package/utils/agnostic/random/index.js

@@ -0,0 +1 @@
+function o(n=1,r){let e=r===void 0?0:n,t=r===void 0?n:r;if(e===t||e>t)return;let u=t-e;return Math.random()*u+e}var f=o;function c(...n){let r=o(...n);return r!==void 0?Math.floor(r):void 0}var d=["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"];function a(){let n=Math.floor(Math.random()*16);return d[n]}function i(n=4){return new Array(n).fill(null).map(a).join("")}function m(n,r="-"){return n.map(i).join(r)}function s(){return m([8,4,4,4,12])}export{f as default,d as hexChars,o as random,i as randomHash,m as randomHashPattern,a as randomHexChar,c as randomInt,s as randomUUID};

package/utils/agnostic/regexp/index.d.ts

@@ -0,0 +1,21 @@
+export declare function mergeFlags(...flagStrs: string[]): string;
+export declare function setFlags(regexp: RegExp, _flags: string): RegExp;
+export declare function fromStart(regexp: RegExp, _flags?: string): RegExp;
+export declare function toEnd(regexp: RegExp, _flags?: string): RegExp;
+export declare function fromStartToEnd(regexp: RegExp, _flags?: string): RegExp;
+export declare function stringStartsWith(string: string, _regexp: RegExp): boolean;
+export declare function stringStartsWith(string: string, _regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
+export declare function stringStartsWith(string: string, _regexp: RegExp, returnMatches: false): boolean;
+export declare function stringStartsWith(string: string, _regexp: RegExp, returnMatches: false, _flags: string): boolean;
+export declare function stringStartsWith(string: string, _regexp: RegExp, returnMatches: true, _flags: string): RegExpMatchArray | null;
+export declare function stringEndsWith(string: string, _regexp: RegExp): boolean;
+export declare function stringEndsWith(string: string, _regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
+export declare function stringEndsWith(string: string, _regexp: RegExp, returnMatches: false): boolean;
+export declare function stringEndsWith(string: string, _regexp: RegExp, returnMatches: false, _flags: string): boolean;
+export declare function stringEndsWith(string: string, _regexp: RegExp, returnMatches: true, _flags: string): RegExpMatchArray | null;
+export declare function stringIs(string: string, _regexp: RegExp): boolean;
+export declare function stringIs(string: string, _regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
+export declare function stringIs(string: string, _regexp: RegExp, returnMatches: false): boolean;
+export declare function stringIs(string: string, _regexp: RegExp, returnMatches: false, _flags: string): boolean;
+export declare function stringIs(string: string, _regexp: RegExp, returnMatches: true, _flags: string): RegExpMatchArray | null;
+export declare function stringsToRegexp(strings: string[]): RegExp;

package/utils/agnostic/regexp/index.js

@@ -0,0 +1 @@
+function i(...t){let n=new Set;return t.forEach(e=>e.split("").forEach(r=>n.add(r))),[...n.values()].join("")}function M(t,n){let e=i(t.flags,n);return new RegExp(`${t.source}`,e)}function x(t,n="g"){let e=i(t.flags,n);return new RegExp(`^(${t.source})`,e)}function c(t,n="g"){let e=i(t.flags,n);return new RegExp(`(${t.source})$`,e)}function R(t,n="g"){let e=i(t.flags,n);return x(c(t,e),e)}function d(t,n,e=!0,r="g"){let s=x(n,r);return e?t.match(s):s.test(t)}function _(t,n,e=!0,r="g"){let s=c(n,r);return e?t.match(s):s.test(t)}function b(t,n,e=!1,r="g"){let s=R(n,r);return e?t.match(s):s.test(t)}function W(t){let n=a(t),e=f(n,!1);return new RegExp(e)}function l(t){return t.replace(/\s/igm,"\\s").replace(/\n/igm,"\\n").replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}function a(t,n=new Map){return t.sort((r,s)=>r.length-s.length).forEach(r=>{let[s,...g]=r,E=g.length===0;if(s===void 0)return;let p=[...n.keys()].find(o=>new RegExp(`^(${l(o)})`).test(r)),u=p!==void 0?n.get(p)?.subRootsMap:void 0;if(p===void 0||u===void 0){let o=new Map;return a([g.join("")],o),n.set(s,{subRootsMap:o,isWordEnd:E})}a([g.join("")],u)}),n}function f(t,n){let e=[...t.entries()];if(e.length===0)return"";let r=e.map(([s,g])=>`${l(s)}${f(g.subRootsMap,g.isWordEnd)}`).join("|");return n?`(${r})?`:`(${r})`}export{x as fromStart,R as fromStartToEnd,i as mergeFlags,M as setFlags,_ as stringEndsWith,b as stringIs,d as stringStartsWith,W as stringsToRegexp,c as toEnd};

package/utils/agnostic/string-matches/index.d.ts

@@ -0,0 +1,4 @@
+export default function stringMatches(input: string, matcher: string | RegExp): boolean;
+export { stringMatches };
+export declare function stringMatchesSome(input: string, matchers: string | RegExp | Array<string | RegExp>): boolean;
+export declare function stringMatchesEvery(input: string, matchers: string | RegExp | Array<string | RegExp>): boolean;

package/utils/agnostic/string-matches/index.js

@@ -0,0 +1 @@
+import{a,b,c}from"../../../chunks/chunk-KNE7WIIW.js";export{a as default,a as stringMatches,c as stringMatchesEvery,b as stringMatchesSome};

package/utils/agnostic/to-alphanum/index.d.ts

@@ -0,0 +1 @@
+export default function toAlphanum(string: string, replacer?: string): string;

package/utils/agnostic/to-alphanum/index.js

@@ -0,0 +1 @@
+function g(e,n=""){let t=e.replace(/[^a-z0-9]/igm,n);return n.length===0?t:t.replace(new RegExp(`${n}+`,"igm"),n)}export{g as default};

package/utils/node/list-subpaths/index.d.ts

@@ -15,8 +15,8 @@ export type Options = {
     dedupeSimlinksContents?: boolean;
     maxDepth?: number;
     returnRelative?: boolean;
-    exclude?: RegExp | null;
-    include?: RegExp | null;
+    exclude?: RegExp | string | (RegExp | string)[] | null;
+    include?: RegExp | string | (RegExp | string)[] | null;
     filter?: ((path: string, details: ChildDetails) => boolean | Promise<boolean>);
 };
 export declare const defaultOptions: Required<Options>;

package/utils/node/list-subpaths/index.js

@@ -1 +1 @@
-import{promises as a}from"node:fs";import h from"node:path";var P={directories:!0,files:!0,symlinks:!0,hidden:!0,followSimlinks:!1,dedupeSimlinksContents:!1,maxDepth:1/0,returnRelative:!1,exclude:null,include:null,filter:()=>!0},w=s=>({...P,...s}),v={depth:0,lstats:null,rootPath:null},g=s=>({...v,...s});async function O(...s){let[u,c]=s,t=w(c??{}),e=await p(...s);return t.returnRelative?e.map(i=>h.relative(u,i)):e}async function p(s,u={},c={}){let t=w(u),e=g(c);e.rootPath===null&&(e.rootPath=s);let i=[];if(e.depth>t.maxDepth)return i;try{if(!(e.lstats??await a.lstat(s)).isDirectory())return i}catch{return i}let S=await a.readdir(s);return await Promise.all(S.map(async d=>{let o=h.join(s,d),k=h.relative(e.rootPath??s,o),r=await a.lstat(o);try{let l=r.isDirectory(),n=r.isSymbolicLink(),f=!l&&!n,x=h.basename(o).startsWith("."),C=l?"directory":n?"symlink":"file";if(l&&t.directories===!1)throw!0;if(n&&t.symlinks===!1||f&&t.files===!1||x&&t.hidden===!1)throw!1;let m=n?await a.realpath(o):o,y=t.returnRelative?k:o,R=t.exclude?.test(y)===!0,D=t.include?.test(y)===!0;if(R&&!D)throw!1;if(!await t.filter(y,{type:C,hidden:x,realPath:m}))throw!0;if(n)if(t.followSimlinks===!1)i.push(o);else{let b=await p(m,t,{...e,depth:e.depth+1});i.push(m,...b)}else if(l){let b=await p(o,t,{...e,depth:e.depth+1,lstats:r});i.push(o,...b)}else i.push(o)}catch(l){if(typeof l!="boolean")throw new Error("This try/catch block should only throw booleans");if(!l)return[];let f=await p(o,t,{...e,depth:e.depth+1,lstats:r});i.push(...f)}})),t.dedupeSimlinksContents?Array.from(new Set(i)):i}export{O as default,v as defaultContext,P as defaultOptions,g as fillContext,w as fillOptions};
+import{b as x}from"../../../chunks/chunk-KNE7WIIW.js";import{promises as a}from"node:fs";import h from"node:path";var P={directories:!0,files:!0,symlinks:!0,hidden:!0,followSimlinks:!1,dedupeSimlinksContents:!1,maxDepth:1/0,returnRelative:!1,exclude:null,include:null,filter:()=>!0},S=s=>({...P,...s}),v={depth:0,lstats:null,rootPath:null},O=s=>({...v,...s});async function E(...s){let[c,u]=s,t=S(u??{}),e=await p(...s);return t.returnRelative?e.map(i=>h.relative(c,i)):e}async function p(s,c={},u={}){let t=S(c),e=O(u);e.rootPath===null&&(e.rootPath=s);let i=[];if(e.depth>t.maxDepth)return i;try{if(!(e.lstats??await a.lstat(s)).isDirectory())return i}catch{return i}let k=await a.readdir(s);return await Promise.all(k.map(async d=>{let o=h.join(s,d),R=h.relative(e.rootPath??s,o),r=await a.lstat(o);try{let n=r.isDirectory(),l=r.isSymbolicLink(),f=!n&&!l,w=h.basename(o).startsWith("."),g=n?"directory":l?"symlink":"file";if(n&&t.directories===!1)throw!0;if(l&&t.symlinks===!1||f&&t.files===!1||w&&t.hidden===!1)throw!1;let m=l?await a.realpath(o):o,y=t.returnRelative?R:o,C=x(y,t.exclude??[]),D=x(y,t.include??[]);if(C&&!D)throw!1;if(!await t.filter(y,{type:g,hidden:w,realPath:m}))throw!0;if(l)if(t.followSimlinks===!1)i.push(o);else{let b=await p(m,t,{...e,depth:e.depth+1});i.push(m,...b)}else if(n){let b=await p(o,t,{...e,depth:e.depth+1,lstats:r});i.push(o,...b)}else i.push(o)}catch(n){if(typeof n!="boolean")throw new Error("This try/catch block should only throw booleans");if(!n)return[];let f=await p(o,t,{...e,depth:e.depth+1,lstats:r});i.push(...f)}})),t.dedupeSimlinksContents?Array.from(new Set(i)):i}export{E as default,v as defaultContext,P as defaultOptions,O as fillContext,S as fillOptions};

package/utils/node/process-exit/index.d.ts

@@ -1,3 +1,5 @@
 export declare const forceExitEvents: string[];
 export declare function beforeForcedExit(callback: () => void | Promise<void>): void;
 export declare function beforeExit(callback: () => void | Promise<void>): void;
+export declare function onExit(callback: () => void | Promise<void>): void;
+export declare function anyway(callback: () => void | Promise<void>): void;

package/utils/node/process-exit/index.js

@@ -1 +1 @@
-var i=["SIGINT","SIGTERM","uncaughtException"];function r(o){i.forEach(e=>process.on(e,o))}function t(o){process.on("beforeExit",o)}export{t as beforeExit,r as beforeForcedExit,i as forceExitEvents};
+var i=["SIGINT","SIGTERM","uncaughtException"];function t(o){i.forEach(e=>process.on(e,o))}function r(o){process.on("beforeExit",o)}function n(o){process.on("exit",o)}function s(o){t(o),r(o),n(o)}export{s as anyway,r as beforeExit,t as beforeForcedExit,i as forceExitEvents,n as onExit};

package/utils/agnostic/array-random-pick/index.d.ts

@@ -1,3 +0,0 @@
-export declare const errorSybol: unique symbol;
-export type ErrorSymbol = typeof errorSybol;
-export default function arrayRandomPick<T>(arr: T[], exclude?: T[]): T | ErrorSymbol;

package/utils/agnostic/array-random-pick/index.js

@@ -1 +0,0 @@
-var f=Symbol();function a(t,e=[]){let r=[...t].filter(l=>!e.includes(l)),o=r.length;if(o===0)return f;let n=Math.floor(Math.random()*o);return r[n]}export{a as default,f as errorSybol};

package/utils/agnostic/find-duplicates-in-array/index.d.ts

@@ -1 +0,0 @@
-export default function findDuplicatesInArray<T>(arr: T[], stopAtFirst?: boolean): T[];

package/utils/agnostic/find-duplicates-in-array/index.js

@@ -1 +0,0 @@
-function o(a,r=!1){let n=new Set,t=new Set;for(let e of a){if(n.has(e)&&r)return[e];n.has(e)&&t.add(e),n.add(e)}return Array.from(t)}export{o as default};

package/utils/agnostic/random-uuid/index.d.ts

@@ -1,5 +0,0 @@
-export declare const hexChars: string[];
-export declare function randomHexChar(): string;
-export declare function randomHash(length?: number): string;
-export declare function randomHashPattern(pattern: number[], joiner?: string): string;
-export default function randomUUID(): string;

package/utils/agnostic/random-uuid/index.js

@@ -1 +0,0 @@
-var o=["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"];function a(){let r=Math.floor(Math.random()*16);return o[r]}function e(r=4){return new Array(r).fill(null).map(n=>a()).join("")}function u(r,n="-"){return r.map(t=>e(t)).join(n)}function i(){return u([8,4,4,4,12])}export{i as default,o as hexChars,e as randomHash,u as randomHashPattern,a as randomHexChar};