jails.stdlib 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Jails.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,22 @@
+
+<div align="center">
+    <h1>jails.std</h1>
+    <h4>The Jails Standard Library</h4>
+</div>
+
+<br />
+
+## Installing
+
+```
+npm install jails.std
+```
+or
+
+```
+yarn add jails.std
+```
+
+<br />
+
+See more details about each module inside their respective folders.

package/build.js

@@ -0,0 +1,34 @@
+const { globSync } = require('glob')
+const { build } = require('vite')
+const path = require('path')
+
+const files = globSync('./**/index.ts')
+    .map( file => {
+        
+        const dirname = path.dirname(file)
+        const filename = path.basename(file) 
+        const name = path.basename(dirname)
+        
+        return {
+            emptyOutDir: false, 
+            target: 'es2015',
+            outDir: path.resolve(`./${dirname}`),
+            lib: {
+                name,
+                entry: `./${dirname}/${filename}`,
+                formats:['umd', 'esm'],
+                fileName: (type) => {
+                    return type == 'umd' ? 'index.umd.js' : 'index.js' 
+                }
+            },
+            rollupOptions: {
+                output: {
+                    exports: 'named'
+                }
+            }   
+        } 
+    })
+
+files.forEach( async (library) => {
+    await build({ build: library })
+})

package/cancelable/README.md

@@ -0,0 +1,41 @@
+
+# cancelable
+```ts 
+cancelable( fn: Function ) : Promise<any>
+```
+
+TIt ensures only the latest async call resolves, ignoring all previous ones, so `.then` runs only for the most recent success and `.catch` only for real errors.
+
+
+### Usage
+
+```js
+import { cancelable } from 'jails.std/cancelable'
+
+export const getService = () => {
+	return new Promise((resolve, reject) => {
+		setTimeout(() => {
+			Math.random() < 0.5
+				? reject({ message: 'Got an error!' })
+				: resolve({ message: 'Success!' })
+		}, 5000)
+	})
+}
+
+const cancelableGetService = cancelable(getService)
+
+  cancelableGetService()
+    .then((result) => console.log(result))
+    .catch((err) => { console.log(err) })
+
+  cancelableGetService()
+    .then((result) => console.log(result))
+    .catch((err) => { console.log(err) })
+
+  cancelableGetService()
+    .then((result) => console.log(result))
+    .catch((err) => { console.log(err) })
+
+```
+
+Only the last `cancelableGetService()` callback will be called, ignoring the other calls.

package/cancelable/index.d.ts

@@ -0,0 +1 @@
+export declare const cancelable: (fn: any) => (...args: any[]) => Promise<unknown>;

package/cancelable/index.js

@@ -0,0 +1,16 @@
+const i = (l) => {
+  let e = 0;
+  return (...n) => {
+    const c = ++e;
+    return new Promise((r, a) => {
+      l(...n).then((t) => {
+        c === e && r(t);
+      }).catch((t) => {
+        c === e && a(t);
+      });
+    });
+  };
+};
+export {
+  i as cancelable
+};

package/cancelable/index.ts

@@ -0,0 +1,18 @@
+
+export const cancelable = (fn) => {
+	let callId = 0
+
+	return (...args) => {
+		const thisCall = ++callId
+
+		return new Promise((resolve, reject) => {
+			fn(...args)
+				.then((val) => {
+					if (thisCall === callId) resolve(val) // only last call resolves
+				})
+				.catch((err) => {
+					if (thisCall === callId) reject(err) // only last call rejects on real error
+				})
+		})
+	}
+}

package/cancelable/index.umd.js

@@ -0,0 +1 @@
+(function(e,n){typeof exports=="object"&&typeof module!="undefined"?n(exports):typeof define=="function"&&define.amd?define(["exports"],n):(e=typeof globalThis!="undefined"?globalThis:e||self,n(e.cancelable={}))})(this,(function(e){"use strict";const n=o=>{let t=0;return(...c)=>{const l=++t;return new Promise((f,d)=>{o(...c).then(i=>{l===t&&f(i)}).catch(i=>{l===t&&d(i)})})}};e.cancelable=n,Object.defineProperty(e,Symbol.toStringTag,{value:"Module"})}));

package/debounce/README.md

@@ -0,0 +1,21 @@
+
+# debounce
+```ts 
+debounce( fn: Function, timeInterval? = 250 )
+```
+
+Delays a function's execution until after a specified pause in activity.
+
+
+### Usage
+
+```js
+import { debounce } from 'jails.std/debounce'
+
+const oninput = debounce(() => {
+  console.log('debouncing input')
+})
+
+input.addEventListener('oninput', oninput)
+
+```

package/debounce/index.d.ts

@@ -0,0 +1 @@
+export declare const debounce: (func: Function, timeout?: number) => (...args: any[]) => void;

package/debounce/index.js

@@ -0,0 +1,11 @@
+const i = (t, o = 250) => {
+  let e;
+  return (...r) => {
+    clearTimeout(e), e = setTimeout(() => {
+      t.apply(void 0, r);
+    }, o);
+  };
+};
+export {
+  i as debounce
+};

package/debounce/index.ts

@@ -0,0 +1,8 @@
+
+export const debounce = (func :Function, timeout: number = 250) => {
+    let timer
+    return (...args) => {
+      clearTimeout(timer)
+      timer = setTimeout(() => { func.apply(this, args) }, timeout)
+    }
+}

package/debounce/index.umd.js

@@ -0,0 +1 @@
+(function(e,t){typeof exports=="object"&&typeof module!="undefined"?t(exports):typeof define=="function"&&define.amd?define(["exports"],t):(e=typeof globalThis!="undefined"?globalThis:e||self,t(e.debounce={}))})(this,(function(e){"use strict";const t=(o,i=250)=>{let n;return(...d)=>{clearTimeout(n),n=setTimeout(()=>{o.apply(void 0,d)},i)}};e.debounce=t,Object.defineProperty(e,Symbol.toStringTag,{value:"Module"})}));

package/delay/README.md

@@ -0,0 +1,17 @@
+## delay
+```ts 
+delay( milliseconds? = 100 ) => ( data: any? ) : Promise<any>
+```
+
+Delays the next `.then` promise chain.
+
+### Usage
+
+```js
+import { delay } from 'jails.std/delay'
+
+fetch('https://jsonplaceholder.typicode.com/todos/1')
+  .then( response => response.json() )
+  .then( delay(2000) )
+  .then( data => console.log( data ) )
+```

package/delay/index.d.ts

@@ -0,0 +1 @@
+export declare const delay: (milisseconds?: number) => (data?: any) => any;

package/delay/index.js

@@ -0,0 +1,6 @@
+const r = (e = 100) => (t) => new Promise((o) => {
+  setTimeout(() => o(t), e);
+});
+export {
+  r as delay
+};

package/delay/index.ts

@@ -0,0 +1,6 @@
+
+export const delay = ( milisseconds:number = 100 ) => ( data? ) : any => {
+	return new Promise((resolve) => {
+		setTimeout(() => resolve( data ), milisseconds )
+	})
+}

package/delay/index.umd.js

@@ -0,0 +1 @@
+(function(e,t){typeof exports=="object"&&typeof module!="undefined"?t(exports):typeof define=="function"&&define.amd?define(["exports"],t):(e=typeof globalThis!="undefined"?globalThis:e||self,t(e.delay={}))})(this,(function(e){"use strict";const t=(n=100)=>i=>new Promise(o=>{setTimeout(()=>o(i),n)});e.delay=t,Object.defineProperty(e,Symbol.toStringTag,{value:"Module"})}));

package/form-validation/index.d.ts

@@ -0,0 +1,18 @@
+export default function formValidation({ main, elm, state, on, emit, dependencies, trigger, }: {
+    main: any;
+    elm: any;
+    state: any;
+    on: any;
+    emit: any;
+    dependencies: any;
+    trigger: any;
+}): void;
+export declare const model: {
+    form: {
+        errors: {};
+        values: {};
+        touched: {};
+        isValid: boolean;
+        focused: {};
+    };
+};

package/form-validation/index.js

@@ -0,0 +1,119 @@
+var T = Object.defineProperty, B = Object.defineProperties;
+var C = Object.getOwnPropertyDescriptors;
+var D = Object.getOwnPropertySymbols;
+var G = Object.prototype.hasOwnProperty, H = Object.prototype.propertyIsEnumerable;
+var A = (a, r, e) => r in a ? T(a, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : a[r] = e, b = (a, r) => {
+  for (var e in r || (r = {}))
+    G.call(r, e) && A(a, e, r[e]);
+  if (D)
+    for (var e of D(r))
+      H.call(r, e) && A(a, e, r[e]);
+  return a;
+}, L = (a, r) => B(a, C(r));
+const M = "form-validation", v = "[data-validation]", J = "[data-mask]";
+function U({
+  main: a,
+  elm: r,
+  state: e,
+  on: n,
+  emit: m,
+  dependencies: y,
+  trigger: F
+}) {
+  var V;
+  const { validations: g, masks: E } = y, f = (V = r.querySelector("input,select,textarea")) == null ? void 0 : V.form;
+  let u = S(f);
+  a((t) => {
+    n("input", "input, textarea, select", z), n("input", J, $), n("input", v, h("input")), n("change", v, h("change")), n("blur", v, h("blur")), n("focus", "input, textarea, select", N), n("blur", "input, textarea, select", O), f.addEventListener("reset", j), f.addEventListener("submit", _), I();
+  });
+  const I = () => {
+    if (!g)
+      throw new Error(
+        "<form-validation> - No validations provided in dependencies"
+      );
+    const t = k();
+    e.set((o) => o.form.values = t);
+  }, k = () => {
+    const t = {};
+    return u.forEach((o) => t[o] = ""), t;
+  }, N = (t) => {
+    const o = t.target.name;
+    e.set((s) => {
+      s.form.touched[o] = !0, s.form.focused[o] = !0;
+    });
+  }, O = (t) => {
+    const o = t.target.name;
+    e.set((s) => {
+      s.form.focused[o] = !1;
+    });
+  }, h = (t) => (o) => {
+    const s = o.target, l = s.name, c = w(s, f), p = s.dataset.validation.split(/\s/), d = [], x = e.get();
+    p.forEach((i) => {
+      if (i in g) {
+        const { ok: q, message: K } = g[i](
+          c,
+          s,
+          f
+        );
+        q || d.push(K);
+      }
+    }), d.length ? t === "input" ? (u.add(s.name), e.set((i) => {
+      i.form.isValid = !1, x.form.errors[l] && d[0] != x.form.errors[l] && (i.form.errors[l] = d[0]);
+    })) : (t === "blur" || t === "change") && (u.add(s.name), e.set((i) => {
+      i.form.errors[l] = d[0], i.form.isValid = !1;
+    })) : (u.delete(s.name), e.set((i) => {
+      delete i.form.errors[l], u.size || (i.form.isValid = !0);
+    }));
+  }, z = (t) => {
+    const { name: o } = t.target, s = w(t.target, f);
+    e.set((l) => l.form.values[o] = s);
+  }, _ = (t) => {
+    t.preventDefault(), F("blur", v);
+    const s = e.get().form.errors;
+    if (Object.keys(s).length)
+      m(`${M}:error`, { errors: s });
+    else {
+      const c = Q(t.target);
+      m(`${M}:submit`, b({}, c));
+    }
+  }, $ = (t) => {
+    let o = t.target.value;
+    const { mask: s } = t.target.dataset;
+    s.split(/s/).forEach((c) => {
+      if (c && c in E) {
+        const p = E[c];
+        o = p(o, t.target, t.target.form);
+      }
+    }), e.set((c) => c.form.values[t.target.name] = o || "");
+  }, j = () => {
+    u = S(f), e.set({
+      form: L(b({}, P.form), {
+        values: k()
+      })
+    });
+  };
+}
+const P = {
+  form: {
+    errors: {},
+    values: {},
+    touched: {},
+    isValid: !1,
+    focused: {}
+  }
+}, Q = (a) => {
+  const r = new FormData(a), e = {};
+  for (let [n, m] of r)
+    e[n] = m;
+  return { formData: r, data: e };
+}, w = (a, r) => {
+  const { name: e, type: n } = a;
+  return n == "checkbox" ? a.checked ? a.value : "" : r[e].value;
+}, S = (a) => {
+  const r = /* @__PURE__ */ new Set();
+  return Array.from(a.elements).filter((e) => e.name && e.dataset.validation).forEach((e) => r.add(e.name)), r;
+};
+export {
+  U as default,
+  P as model
+};

package/form-validation/index.ts

@@ -0,0 +1,198 @@
+const NAME = 'form-validation'
+const DVALIDATION = `[data-validation]`
+const DMASK = '[data-mask]'
+
+export default function formValidation({
+	main,
+	elm,
+	state,
+	on,
+	emit,
+	dependencies,
+	trigger,
+}) {
+	//
+	const { validations, masks } = dependencies
+	const form = elm.querySelector('input,select,textarea')?.form
+	let fields = getFields(form)
+
+	main((_) => {
+		on('input', 'input, textarea, select', update)
+		on('input', DMASK, handleMask)
+		on('input', DVALIDATION, validate('input'))
+		on('change', DVALIDATION, validate('change'))
+		on('blur', DVALIDATION, validate('blur'))
+		on('focus', 'input, textarea, select', onfocus)
+		on('blur', 'input, textarea, select', onblur)
+
+		form.addEventListener('reset', reset)
+		form.addEventListener('submit', onsubmit)
+
+		initialValues()
+	})
+
+	const initialValues = () => {
+		if (!validations) {
+			throw new Error(
+				'<form-validation> - No validations provided in dependencies'
+			)
+		}
+		const fields = getInitialValues()
+		state.set((s) => (s.form.values = fields))
+	}
+
+	const getInitialValues = () => {
+		const fields_ = {}
+		fields.forEach((name:string) => (fields_[name] = ''))
+		return fields_
+	}
+
+	const onfocus = (e) => {
+		const name = e.target.name
+		state.set((s) => {
+			s.form.touched[name] = true
+			s.form.focused[name] = true
+		})
+	}
+
+	const onblur = (e) => {
+		const name = e.target.name
+		state.set((s) => {
+			s.form.focused[name] = false
+		})
+	}
+
+	const validate = (type) => (e) => {
+		const input = e.target
+		const name = input.name
+		const value = getValueOfField(input, form)
+		const validationList = input.dataset.validation.split(/\s/)
+		const errorsList = []
+		const currentState = state.get()
+
+		validationList.forEach((validation) => {
+			if (validation in validations) {
+				const { ok, message } = validations[validation](
+					value,
+					input,
+					form
+				)
+				if (!ok) {
+					errorsList.push(message)
+				}
+			}
+		})
+
+		if (errorsList.length) {
+			if (type === 'input') {
+				fields.add(input.name)
+				state.set((s) => {
+					s.form.isValid = false
+					if (
+						currentState.form.errors[name] &&
+						errorsList[0] != currentState.form.errors[name]
+					) {
+						s.form.errors[name] = errorsList[0]
+					}
+				})
+			} else if (type === 'blur' || type === 'change') {
+				fields.add(input.name)
+				state.set((s) => {
+					s.form.errors[name] = errorsList[0]
+					s.form.isValid = false
+				})
+			}
+		} else {
+			fields.delete(input.name)
+			state.set((s) => {
+				delete s.form.errors[name]
+				if (!fields.size) {
+					s.form.isValid = true
+				}
+			})
+		}
+	}
+
+	const update = (e) => {
+		const { name } = e.target
+		const value = getValueOfField(e.target, form)
+		state.set((s) => (s.form.values[name] = value))
+	}
+
+	const onsubmit = (e) => {
+		e.preventDefault()
+		trigger('blur', DVALIDATION)
+
+		const data = state.get()
+		const errors = data.form.errors
+		const hasErrors = Object.keys(errors).length
+
+		if (!hasErrors) {
+			const data = serialize(e.target)
+			emit(`${NAME}:submit`, { ...data })
+		} else {
+			emit(`${NAME}:error`, { errors })
+		}
+	}
+
+	const handleMask = (e) => {
+		let value = e.target.value
+		const { mask } = e.target.dataset
+		const allMasks = mask.split(/s/)
+
+		allMasks.forEach((mask) => {
+			if (mask && mask in masks) {
+				const fn = masks[mask]
+				value = fn(value, e.target, e.target.form)
+			}
+		})
+
+		state.set((s) => (s.form.values[e.target.name] = value || ''))
+	}
+
+	const reset = () => {
+		fields = getFields(form)
+		state.set({
+			form: {
+				...model.form,
+				values: getInitialValues()
+			}
+		})
+	}
+}
+
+export const model = {
+	form: {
+		errors: {},
+		values: {},
+		touched: {},
+		isValid: false,
+		focused: {}
+	}
+}
+
+const serialize = (form) => {
+	const formData = new FormData(form)
+	const data = {}
+	for (let [key, value] of formData) {
+		data[key] = value
+	}
+	return { formData, data }
+}
+
+const getValueOfField = (field, form) => {
+	const { name, type } = field
+	if (type == 'checkbox') {
+		return field.checked ? field.value : ''
+	} else {
+		return form[name].value
+	}
+}
+
+const getFields = (form) => {
+	const list = new Set()
+	Array.from(form.elements)
+		.filter((field:any) => field.name && field.dataset.validation)
+		.forEach((field:any) => list.add(field.name))
+	return list
+}

package/form-validation/index.umd.js

@@ -0,0 +1 @@
+(function(o,r){typeof exports=="object"&&typeof module!="undefined"?r(exports):typeof define=="function"&&define.amd?define(["exports"],r):(o=typeof globalThis!="undefined"?globalThis:o||self,r(o["form-validation"]={}))})(this,(function(o){"use strict";var H=Object.defineProperty,J=Object.defineProperties;var Q=Object.getOwnPropertyDescriptors;var L=Object.getOwnPropertySymbols;var R=Object.prototype.hasOwnProperty,U=Object.prototype.propertyIsEnumerable;var w=(o,r,n)=>r in o?H(o,r,{enumerable:!0,configurable:!0,writable:!0,value:n}):o[r]=n,k=(o,r)=>{for(var n in r||(r={}))R.call(r,n)&&w(o,n,r[n]);if(L)for(var n of L(r))U.call(r,n)&&w(o,n,r[n]);return o},O=(o,r)=>J(o,Q(r));const r="form-validation",n="[data-validation]",T="[data-mask]";function _({main:c,elm:f,state:t,on:i,emit:p,dependencies:F,trigger:I}){var S;const{validations:h,masks:y}=F,m=(S=f.querySelector("input,select,textarea"))==null?void 0:S.form;let v=x(m);c(e=>{i("input","input, textarea, select",q),i("input",T,P),i("input",n,b("input")),i("change",n,b("change")),i("blur",n,b("blur")),i("focus","input, textarea, select",z),i("blur","input, textarea, select",$),m.addEventListener("reset",B),m.addEventListener("submit",K),N()});const N=()=>{if(!h)throw new Error("<form-validation> - No validations provided in dependencies");const e=D();t.set(a=>a.form.values=e)},D=()=>{const e={};return v.forEach(a=>e[a]=""),e},z=e=>{const a=e.target.name;t.set(s=>{s.form.touched[a]=!0,s.form.focused[a]=!0})},$=e=>{const a=e.target.name;t.set(s=>{s.form.focused[a]=!1})},b=e=>a=>{const s=a.target,u=s.name,d=M(s,m),E=s.dataset.validation.split(/\s/),g=[],A=t.get();E.forEach(l=>{if(l in h){const{ok:C,message:G}=h[l](d,s,m);C||g.push(G)}}),g.length?e==="input"?(v.add(s.name),t.set(l=>{l.form.isValid=!1,A.form.errors[u]&&g[0]!=A.form.errors[u]&&(l.form.errors[u]=g[0])})):(e==="blur"||e==="change")&&(v.add(s.name),t.set(l=>{l.form.errors[u]=g[0],l.form.isValid=!1})):(v.delete(s.name),t.set(l=>{delete l.form.errors[u],v.size||(l.form.isValid=!0)}))},q=e=>{const{name:a}=e.target,s=M(e.target,m);t.set(u=>u.form.values[a]=s)},K=e=>{e.preventDefault(),I("blur",n);const s=t.get().form.errors;if(Object.keys(s).length)p(`${r}:error`,{errors:s});else{const d=j(e.target);p(`${r}:submit`,k({},d))}},P=e=>{let a=e.target.value;const{mask:s}=e.target.dataset;s.split(/s/).forEach(d=>{if(d&&d in y){const E=y[d];a=E(a,e.target,e.target.form)}}),t.set(d=>d.form.values[e.target.name]=a||"")},B=()=>{v=x(m),t.set({form:O(k({},V.form),{values:D()})})}}const V={form:{errors:{},values:{},touched:{},isValid:!1,focused:{}}},j=c=>{const f=new FormData(c),t={};for(let[i,p]of f)t[i]=p;return{formData:f,data:t}},M=(c,f)=>{const{name:t,type:i}=c;return i=="checkbox"?c.checked?c.value:"":f[t].value},x=c=>{const f=new Set;return Array.from(c.elements).filter(t=>t.name&&t.dataset.validation).forEach(t=>f.add(t.name)),f};o.default=_,o.model=V,Object.defineProperties(o,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})}));