* Fixed cache value type

+ Caching manually expire
+ Caching expiry strategies
2025-05-13 10:53:17 -04:00 · 2025-05-12 20:29:29 -04:00 · 2025-05-12 19:46:23 -04:00 · 2025-05-12 18:00:12 -04:00 · 2025-05-12 16:28:10 -04:00 · 2025-05-11 14:13:01 -04:00
12 changed files with 199 additions and 182 deletions
--- a/index.html
+++ b/index.html
@ -1,104 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-	<head>
-		<meta charset="UTF-8" />
-		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
-		<title>About Us | OurTrainingRoom</title>
-		<style>
-			body {
-				margin: 0;
-				font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-				background-color: #fdfdfd;
-				color: #333;
-				line-height: 1.6;
-			}
-			header {
-				background: #004080;
-				color: #fff;
-				padding: 2rem 1rem;
-				text-align: center;
-			}
-			header h1 {
-				margin: 0;
-				font-size: 2.5rem;
-			}
-			main {
-				max-width: 800px;
-				margin: 2rem auto;
-				padding: 0 1rem;
-			}
-			section {
-				margin-bottom: 2rem;
-			}
-			h2 {
-				color: #004080;
-				margin-bottom: 0.5rem;
-			}
-			ul {
-				padding-left: 1.25rem;
-			}
-			footer {
-				text-align: center;
-				font-size: 0.9rem;
-				color: #777;
-				padding: 2rem 1rem;
-				background: #f1f1f1;
-				margin-top: 4rem;
-			}
-		</style>
-	</head>
-	<body>
-		<header>
-			<h1>About Us</h1>
-			<p>Empowering Learning Through Innovation</p>
-		</header>
-
-		<main>
-			<section>
-				<p>
-					E-learning has evolved significantly since its inception. Today, there's a shift towards
-					blended learning services, integrating online activities with practical, real-world applications.
-				</p>
-			</section>
-
-			<section>
-				<h2>What We Do</h2>
-				<p>At <strong>OurTrainingRoom.com</strong>, we specialize in content management and professional development training tailored for:</p>
-				<ul>
-					<li>School Boards</li>
-					<li>Municipalities</li>
-					<li>Hospitals</li>
-					<li>Large Corporations</li>
-				</ul>
-			</section>
-
-			<section>
-				<h2>Our Roots</h2>
-				<p>
-					Our parent company, <strong>The Auxilium Group</strong>, is a leader in online data management.
-					The formation of OurTrainingRoom.com was a natural progression to deliver state-of-the-art front-end e-learning programs.
-				</p>
-			</section>
-
-			<section>
-				<h2>Our Approach</h2>
-				<p>
-					Built on principles of quality and continuous improvement, our diverse delivery range continues to grow.
-					We set new trends by enhancing our existing products and attentively listening to our clients and their employees.
-					This unique approach has solidified our position in the industry, making a substantial impact for our clients.
-				</p>
-			</section>
-
-			<section>
-				<h2>Have a Question?</h2>
-				<p>
-					We value your inquiries and are here to assist you. Please reach out with any questions or feedback.
-				</p>
-			</section>
-		</main>
-
-		<footer>
-			&copy; 2025 OurTrainingRoom.com. All rights reserved.
-		</footer>
-	</body>
-</html>
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
 	"name": "@ztimson/utils",
-	"version": "0.24.2",
+	"version": "0.24.10",
 	"description": "Utility library",
 	"author": "Zak Timson",
 	"license": "MIT",
@ -26,6 +26,9 @@
 		"test:coverage": "npx jest --coverage",
 		"watch": "npx vite build --watch"
 	},
+	"dependencies": {
+		"var-persist": "^1.0.1"
+	},
 	"devDependencies": {
 		"@types/jest": "^29.5.12",
 		"jest": "^29.7.0",
--- a/src/aset.ts
+++ b/src/aset.ts
@ -29,6 +29,14 @@ export class ASet<T> extends Array {
 		return this;
 	}

+	/**
+	 * Remove all elements
+	 */
+	clear() {
+		this.splice(0, this.length);
+		return this;
+	}
+
 	/**
 	 * Delete elements from set
 	 * @param items Elements that will be deleted
--- a/src/cache.ts
+++ b/src/cache.ts
@ -7,16 +7,20 @@ export type CacheOptions = {
 	storage?: Storage;
 	/** Key cache will be stored under */
 	storageKey?: string;
+	/** Keep or delete cached items once expired, defaults to delete */
+	expiryPolicy?: 'delete' | 'keep';
 }

+export type CachedValue<T> = T & {_expired?: boolean};
+
 /**
 * Map of data which tracks whether it is a complete collection & offers optional expiry of cached values
 */
 export class Cache<K extends string | number | symbol, T> {
-	private store = <Record<K, T>>{};
+	private store: Record<K, T> = <any>{};

 	/** Support index lookups */
-	[key: string | number | symbol]: T | any;
+	[key: string | number | symbol]: CachedValue<T> | any;
 	/** Whether cache is complete */
 	complete = false;

@ -38,7 +42,7 @@ export class Cache<K extends string | number | symbol, T> {
 		return new Proxy(this, {
 			get: (target: this, prop: string | symbol) => {
 				if(prop in target) return (target as any)[prop];
-				return deepCopy(target.store[prop as K]);
+				return this.get(prop as K, true);
 			},
 			set: (target: this, prop: string | symbol, value: any) => {
 				if(prop in target) (target as any)[prop] = value;
@ -53,12 +57,18 @@ export class Cache<K extends string | number | symbol, T> {
 		return <K>value[this.key];
 	}

+	private save() {
+		if(this.options.storageKey && this.options.storage)
+			this.options.storage.setItem(this.options.storageKey, JSON.stringify(this.store));
+	}
+
 	/**
 	 * Get all cached items
 	 * @return {T[]} Array of items
 	 */
-	all(): T[] {
-		return deepCopy(Object.values(this.store));
+	all(expired?: boolean): CachedValue<T>[] {
+		return deepCopy<any>(Object.values(this.store)
+			.filter((v: any) => expired || !v._expired));
 	}

 	/**
@ -90,7 +100,8 @@ export class Cache<K extends string | number | symbol, T> {
 	 * Remove all keys from cache
 	 */
 	clear() {
-		this.store = <Record<K, T>>{};
+		this.complete = false;
+		this.store = <any>{};
 	}

 	/**
@ -99,16 +110,26 @@ export class Cache<K extends string | number | symbol, T> {
 	 */
 	delete(key: K) {
 		delete this.store[key];
-		if(this.options.storageKey && this.options.storage)
-			this.options.storage.setItem(this.options.storageKey, JSON.stringify(this.store));
+		this.save();
 	}

 	/**
 	 * Return cache as an array of key-value pairs
 	 * @return {[K, T][]} Key-value pairs array
 	 */
-	entries(): [K, T][] {
-		return <[K, T][]>Object.entries(this.store);
+	entries(expired?: boolean): [K, CachedValue<T>][] {
+		return deepCopy<any>(Object.entries(this.store)
+			.filter((v: any) => expired || !v._expired));
+	}
+
+	/**
+	 * Manually expire a cached item
+	 * @param {K} key Key to expire
+	 */
+	expire(key: K) {
+		this.complete = false;
+		if(this.options.expiryPolicy == 'keep') (<any>this.store[key])._expired = true;
+		else this.delete(key);
 	}

 	/**
@ -116,24 +137,31 @@ export class Cache<K extends string | number | symbol, T> {
 	 * @param {K} key Key to lookup
 	 * @return {T} Cached item
 	 */
-	get(key: K): T {
-		return deepCopy(this.store[key]);
+	get(key: K, expired?: boolean): T | null {
+		const cached = deepCopy<any>(this.store[key] ?? null);
+		if(expired || !cached._expired) return cached;
+		return null;
 	}

 	/**
 	 * Get a list of cached keys
 	 * @return {K[]} Array of keys
 	 */
-	keys(): K[] {
-		return <K[]>Object.keys(this.store);
+	keys(expired?: boolean): K[] {
+		return <K[]>Object.keys(this.store)
+			.filter(k => expired || !(<any>this.store)[k]._expired);
 	}

 	/**
 	 * Get map of cached items
 	 * @return {Record<K, T>}
 	 */
-	map(): Record<K, T> {
-		return deepCopy(this.store);
+	map(expired?: boolean): Record<K, CachedValue<T>> {
+		const copy: any = deepCopy(this.store);
+		if(!expired) Object.keys(copy).forEach(k => {
+			if(copy[k]._expired) delete copy[k]
+		});
+		return copy;
 	}

 	/**
@ -144,12 +172,12 @@ export class Cache<K extends string | number | symbol, T> {
 	 * @return {this}
 	 */
 	set(key: K, value: T, ttl = this.options.ttl): this {
+		if(this.options.expiryPolicy == 'keep') delete (<any>this.store[key])._expired;
 		this.store[key] = value;
-		if(this.options.storageKey && this.options.storage)
-			this.options.storage.setItem(this.options.storageKey, JSON.stringify(this.store));
+		this.save();
 		if(ttl) setTimeout(() => {
-			this.complete = false;
-			this.delete(key);
+			this.expire(key);
+			this.save();
 		}, ttl * 1000);
 		return this;
 	}
--- a/src/index.ts
+++ b/src/index.ts
@ -19,3 +19,4 @@ export * from './search';
 export * from './string';
 export * from './time';
 export * from './types';
+export * from 'var-persist';
--- a/src/path-events.ts
+++ b/src/path-events.ts
@ -31,7 +31,7 @@ export function PE(str: TemplateStringsArray, ...args: any[]) {
 		if(str[i]) combined.push(str[i]);
 		if(args[i]) combined.push(args[i]);
 	}
-	return new PathEvent(combined.join(''));
+	return new PathEvent(combined.join('/'));
 }

 /**
@ -79,20 +79,20 @@ export class PathEvent {
 	set none(v: boolean) { v ? this.methods = new ASet<Method>(['n']) : this.methods.delete('n'); }
 	/** Create method specified */
 	get create(): boolean { return !this.methods.has('n') && (this.methods.has('*') || this.methods.has('c')) }
-	set create(v: boolean) { v ? this.methods.delete('n').add('c') : this.methods.delete('c'); }
+	set create(v: boolean) { v ? this.methods.delete('n').delete('*').add('c') : this.methods.delete('c'); }
 	/** Read method specified */
 	get read(): boolean { return !this.methods.has('n') && (this.methods.has('*') || this.methods.has('r')) }
-	set read(v: boolean) { v ? this.methods.delete('n').add('r') : this.methods.delete('r'); }
+	set read(v: boolean) { v ? this.methods.delete('n').delete('*').add('r') : this.methods.delete('r'); }
 	/** Update method specified */
 	get update(): boolean { return !this.methods.has('n') && (this.methods.has('*') || this.methods.has('u')) }
-	set update(v: boolean) { v ? this.methods.delete('n').add('u') : this.methods.delete('u'); }
+	set update(v: boolean) { v ? this.methods.delete('n').delete('*').add('u') : this.methods.delete('u'); }
 	/** Delete method specified */
 	get delete(): boolean { return !this.methods.has('n') && (this.methods.has('*') || this.methods.has('d')) }
-	set delete(v: boolean) { v ? this.methods.delete('n').add('d') : this.methods.delete('d'); }
+	set delete(v: boolean) { v ? this.methods.delete('n').delete('*').add('d') : this.methods.delete('d'); }

-	constructor(Event: string | PathEvent) {
-		if(typeof Event == 'object') return Object.assign(this, Event);
-		let [p, scope, method] = Event.replaceAll(/\/{2,}/g, '/').split(':');
+	constructor(e: string | PathEvent) {
+		if(typeof e == 'object') return Object.assign(this, e);
+		let [p, scope, method] = e.replaceAll(/\/{2,}/g, '/').split(':');
 		if(!method) method = scope || '*';
 		if(p == '*' || !p && method == '*') {
 			p = '';
@ -100,14 +100,14 @@ export class PathEvent {
 		}
 		let temp = p.split('/').filter(p => !!p);
 		this.module = temp.splice(0, 1)[0]?.toLowerCase() || '';
-		this.fullPath = p;
 		this.path = temp.join('/');
+		this.fullPath = `${this.module}${this.module && this.path ? '/' : ''}${this.path}`;
 		this.name = temp.pop() || '';
 		this.methods = new ASet(<any>method.split(''));
 	}

 	/**
-	 * Combine multiple  events into one parsed object. Longest path takes precedent, but all subsequent methods are
+	 * Combine multiple events into one parsed object. Longest path takes precedent, but all subsequent methods are
 	 * combined until a "none" is reached
 	 *
 	 * @param {string | PathEvent} paths Events as strings or pre-parsed
@ -199,14 +199,14 @@ export class PathEvent {
 	}

 	/**
-	 * Create  event string from its components
+	 * Create event string from its components
 	 *
 	 * @param {string | string[]} path Event path
 	 * @param {Method} methods Event method
 	 * @return {string} String representation of Event
 	 */
 	static toString(path: string | string[], methods: Method | Method[]): string {
-		let p = makeArray(path).filter(p => p != null).join('/');
+		let p = makeArray(path).filter(p => !!p).join('/');
 		p = p?.trim().replaceAll(/\/{2,}/g, '/').replaceAll(/(^\/|\/$)/g, '');
 		if(methods?.length) p += `:${makeArray(methods).map(m => m.toLowerCase()).join('')}`;
 		return p;
@ -223,7 +223,7 @@ export class PathEvent {
 	}

 	/**
-	 * Create  event string from its components
+	 * Create event string from its components
 	 *
 	 * @return {string} String representation of Event
 	 */
@ -235,11 +235,12 @@ export class PathEvent {
 export type PathListener = (event: PathEvent, ...args: any[]) => any;
 export type PathUnsubscribe = () => void;

+export type Event = string | PathEvent;
 export interface IPathEventEmitter {
-	emit(event: string, ...args: any[]): void;
+	emit(event: Event, ...args: any[]): void;
 	off(listener: PathListener): void;
-	on(event: string, listener: PathListener): PathUnsubscribe;
-	once(event: string, listener?: PathListener): Promise<any>;
+	on(event: Event | Event[], listener: PathListener): PathUnsubscribe;
+	once(event: Event | Event[], listener?: PathListener): Promise<any>;
 	relayEvents(emitter: PathEventEmitter): void;
 }

@ -249,8 +250,10 @@ export interface IPathEventEmitter {
 export class PathEventEmitter implements IPathEventEmitter{
 	private listeners: [PathEvent, PathListener][] = [];

-	emit(event: string | PathEvent, ...args: any[]) {
-		const parsed = new PathEvent(event);
+	constructor(public readonly prefix: string = '') { }
+
+	emit(event: Event, ...args: any[]) {
+		const parsed = new PathEvent(`${this.prefix}/${typeof event == 'string' ? event : event.toString()}`);
 		this.listeners.filter(l => PathEvent.has(l[0], event))
 			.forEach(async l => l[1](parsed, ...args));
 	};
@ -259,12 +262,15 @@ export class PathEventEmitter implements IPathEventEmitter{
 		this.listeners = this.listeners.filter(l => l[1] != listener);
 	}

-	on(event: string | string[], listener: PathListener): PathUnsubscribe {
-		makeArray(event).forEach(e => this.listeners.push([new PathEvent(e), listener]));
+	on(event: Event | Event[], listener: PathListener): PathUnsubscribe {
+		makeArray(event).forEach(e => this.listeners.push([
+			new PathEvent(`${this.prefix}/${typeof e == 'string' ? event : event.toString()}`),
+			listener
+		]));
 		return () => this.off(listener);
 	}

-	once(event: string | string[], listener?: PathListener): Promise<any> {
+	once(event: Event | Event[], listener?: PathListener): Promise<any> {
 		return new Promise(res => {
 			const unsubscribe = this.on(event, (event: PathEvent, ...args: any[]) => {
 				res(args.length < 2 ? args[0] : args);
--- a/src/search.ts
+++ b/src/search.ts
@ -1,4 +1,4 @@
-import {dotNotation, JSONAttemptParse} from './objects.ts';
+import {dotNotation, JSONAttemptParse, JSONSerialize} from './objects.ts';

 export function search(rows: any[], search: string, regex?: boolean, transform: Function = (r: any) => r) {
 	if(!rows) return [];
@ -13,12 +13,18 @@ export function search(rows: any[], search: string, regex?: boolean, transform:
 				catch { return false; }
 			}).length
 		} else {
-			return testCondition(search, r);
+			return logicTest(r, search);
 		}
 	});
 }

-export function testCondition(condition: string, row: any) {
+/**
+ * Test an object against a logic condition. By default values are checked
+ * @param {string} condition
+ * @param {object} target
+ * @return {boolean}
+ */
+export function logicTest(target: object, condition: string): boolean {
 	const evalBoolean = (a: any, op: string, b: any): boolean => {
 		switch(op) {
 			case '=':
@ -40,11 +46,11 @@ export function testCondition(condition: string, row: any) {
 			// Boolean operator
 			const prop = /(\S+)\s*(==?|!=|>=|>|<=|<)\s*(\S+)/g.exec(p);
 			if(prop) {
-				const key = Object.keys(row).find(k => k.toLowerCase() == prop[1].toLowerCase());
-				return evalBoolean(dotNotation<any>(row, key || prop[1]),  prop[2], JSONAttemptParse(prop[3]));
+				const key = Object.keys(target).find(k => k.toLowerCase() == prop[1].toLowerCase());
+				return evalBoolean(dotNotation<any>(target, key || prop[1]),  prop[2], JSONAttemptParse(prop[3]));
 			}
 			// Case-sensitive
-			const v = Object.values(row).map(v => typeof v == 'object' && v != null ? JSON.stringify(v) : v).join('');
+			const v = Object.values(target).map(JSONSerialize).join('');
 			if(/[A-Z]/g.test(condition)) return v.includes(p);
 			// Case-insensitive
 			return v.toLowerCase().includes(p);
--- a/src/types.ts
+++ b/src/types.ts
@ -18,3 +18,10 @@
 export function typeKeys<T extends object>() {
 	return Object.keys(<T>{}) as Array<keyof T>;
 }
+
+/**
+ * Mark all properties as writable
+ */
+export type Writable<T> = {
+	-readonly [P in keyof T]: T[P]
+};
--- a/tests/misc.spec.ts
+++ b/tests/misc.spec.ts
@ -1,36 +1,18 @@
-import {sleep, parseUrl} from '../src';
+import {fn} from '../src';

 describe('Miscellanies Utilities', () => {
-	describe('sleep', () => {
-		test('wait until', async () => {
-			const wait = ~~(Math.random() * 500);
-			const time = new Date().getTime();
-			await sleep(wait);
-			expect(new Date().getTime()).toBeGreaterThanOrEqual(time + wait);
-		});
-	});
-
-	describe('urlParser', () => {
-		test('localhost w/ port', () => {
-			const parsed = parseUrl('http://localhost:4200/some/path?q1=test1&q2=test2#frag');
-			expect(parsed.protocol).toStrictEqual('http');
-			expect(parsed.host).toStrictEqual('localhost:4200');
-			expect(parsed.domain).toStrictEqual('localhost');
-			expect(parsed.port).toStrictEqual(4200);
-			expect(parsed.path).toStrictEqual('/some/path');
-			expect(parsed.query).toStrictEqual({q1: 'test1', q2: 'test2'});
-			expect(parsed.fragment).toStrictEqual('frag');
+	describe('fn', () => {
+		test('async', async () => {
+			const test = {a: Math.random()};
+			const resp = fn(test, 'return a;', true);
+			expect(resp instanceof Promise).toBeTruthy();
+			expect(await resp).toEqual(test['a']);
 		});

-		test('advanced URL', () => {
-			const parsed = parseUrl('https://sub.domain.example.com/some/path?q1=test1&q2=test2#frag');
-			expect(parsed.protocol).toStrictEqual('https');
-			expect(parsed.host).toStrictEqual('sub.domain.example.com');
-			expect(parsed.domain).toStrictEqual('example.com');
-			expect(parsed.subdomain).toStrictEqual('sub.domain');
-			expect(parsed.path).toStrictEqual('/some/path');
-			expect(parsed.query).toStrictEqual({q1: 'test1', q2: 'test2'});
-			expect(parsed.fragment).toStrictEqual('frag');
+		test('sync', async () => {
+			const test = {a: Math.random()};
+			const resp = fn(test, 'return a;3');
+			expect(resp).toEqual(test['a']);
 		});
 	});
 });
--- a/tests/path-events.spec.ts
+++ b/tests/path-events.spec.ts
@ -0,0 +1,43 @@
+import {PathEvent} from '../src';
+
+describe('Path Events', () => {
+	describe('malformed', () => {
+		test('starting slash', async () =>
+			expect(new PathEvent('/module').toString()).toEqual('module:*'));
+		test('trailing slash', async () =>
+			expect(new PathEvent('module/').toString()).toEqual('module:*'));
+		test('double slash', async () =>
+			expect(new PathEvent('module////path').toString()).toEqual('module/path:*'));
+	});
+
+	describe('methods', () => {
+		test('custom', async () => {
+			expect(new PathEvent('module:t').methods.includes('t')).toBeTruthy();
+			expect(new PathEvent('module:t').methods.includes('z')).toBeFalsy();
+		});
+		test('create', async () =>
+			expect(new PathEvent('module:crud').create).toBeTruthy());
+		test('read', async () =>
+			expect(new PathEvent('module:crud').read).toBeTruthy());
+		test('update', async () =>
+			expect(new PathEvent('module:crud').update).toBeTruthy());
+		test('delete', async () =>
+			expect(new PathEvent('module:crud').delete).toBeTruthy());
+		test('none', async () => {
+			const event = new PathEvent('module:n');
+			expect(event.none).toBeTruthy();
+			expect(event.create).toBeFalsy();
+			expect(event.read).toBeFalsy();
+			expect(event.update).toBeFalsy();
+			expect(event.delete).toBeFalsy()
+		});
+		test('wildcard', async () => {
+			const event = new PathEvent('module:*');
+			expect(event.none).toBeFalsy();
+			expect(event.create).toBeTruthy();
+			expect(event.read).toBeTruthy();
+			expect(event.update).toBeTruthy();
+			expect(event.delete).toBeTruthy()
+		});
+	});
+});
--- a/tests/string.spec.ts
+++ b/tests/string.spec.ts
@ -1,4 +1,5 @@
-import {matchAll, randomString, randomStringBuilder} from "../src";
+import {matchAll, parseUrl, randomString, randomStringBuilder} from "../src";
+

 describe('String Utilities', () => {
 	describe('randomString', () => {
@ -47,4 +48,28 @@ describe('String Utilities', () => {
 		test('using regex', () => expect(matchAll('fooBar fooBar FooBar', /fooBar/g).length).toBe(2));
 		test('using malformed regex', () => expect(() => matchAll('fooBar fooBar FooBar', /fooBar/)).toThrow());
 	});
+
+	describe('urlParser', () => {
+		test('localhost', () => {
+			const parsed = parseUrl('http://localhost:4200/some/path?q1=test1&q2=test2#frag');
+			expect(parsed.protocol).toStrictEqual('http');
+			expect(parsed.host).toStrictEqual('localhost:4200');
+			expect(parsed.domain).toStrictEqual('localhost');
+			expect(parsed.port).toStrictEqual(4200);
+			expect(parsed.path).toStrictEqual('/some/path');
+			expect(parsed.query).toStrictEqual({q1: 'test1', q2: 'test2'});
+			expect(parsed.fragment).toStrictEqual('frag');
+		});
+
+		test('subdomains', () => {
+			const parsed = parseUrl('https://sub.domain.example.com/some/path?q1=test1&q2=test2#frag');
+			expect(parsed.protocol).toStrictEqual('https');
+			expect(parsed.host).toStrictEqual('sub.domain.example.com');
+			expect(parsed.domain).toStrictEqual('example.com');
+			expect(parsed.subdomain).toStrictEqual('sub.domain');
+			expect(parsed.path).toStrictEqual('/some/path');
+			expect(parsed.query).toStrictEqual({q1: 'test1', q2: 'test2'});
+			expect(parsed.fragment).toStrictEqual('frag');
+		});
+	});
 });
--- a/tests/time.spec.ts
+++ b/tests/time.spec.ts
@ -0,0 +1,12 @@
+import {sleep} from '../src';
+
+describe('Time Utilities', () => {
+	describe('sleep', () => {
+		test('wait until', async () => {
+			const wait = ~~(Math.random() * 500);
+			const time = new Date().getTime();
+			await sleep(wait);
+			expect(new Date().getTime()).toBeGreaterThanOrEqual(time + wait);
+		});
+	});
+});
Author	SHA1	Message	Date
ztimson	4fecf10d11	* Fixed cache value type All checks were successful Build / Build NPM Project (push) Successful in 1m16s Details Build / Tag Version (push) Successful in 14s Details Build / Publish Documentation (push) Successful in 54s Details	2025-05-13 10:53:17 -04:00
ztimson	028b9c0f4c	+ Caching manually expire All checks were successful Build / Build NPM Project (push) Successful in 41s Details Build / Tag Version (push) Successful in 8s Details Build / Publish Documentation (push) Successful in 36s Details	2025-05-12 20:29:29 -04:00
ztimson	d938996a66	+ Caching expiry strategies Some checks failed Build / Build NPM Project (push) Failing after 34s Details Build / Publish Documentation (push) Has been skipped Details Build / Tag Version (push) Has been skipped Details + Prefix PathEvents	2025-05-12 19:46:23 -04:00
ztimson	cdcaeda67c	+ Added writable All checks were successful Build / Build NPM Project (push) Successful in 40s Details Build / Tag Version (push) Successful in 8s Details Build / Publish Documentation (push) Successful in 35s Details	2025-05-12 18:00:12 -04:00
ztimson	482c90b53b	+ Added writable All checks were successful Build / Build NPM Project (push) Successful in 1m13s Details Build / Tag Version (push) Successful in 15s Details Build / Publish Documentation (push) Successful in 49s Details	2025-05-12 16:28:10 -04:00
ztimson	7500ba502f	+ Added clear function to ASet All checks were successful Build / Build NPM Project (push) Successful in 44s Details Build / Tag Version (push) Successful in 8s Details Build / Publish Documentation (push) Successful in 37s Details * fixed pathedEvent fullPath casing	2025-05-11 14:13:01 -04:00
ztimson	edc059d17d	Added var-persist All checks were successful Build / Build NPM Project (push) Successful in 37s Details Build / Tag Version (push) Successful in 8s Details Build / Publish Documentation (push) Successful in 35s Details	2025-05-11 11:55:40 -04:00
ztimson	48cfbee46e	Removed test All checks were successful Build / Build NPM Project (push) Successful in 1m8s Details Build / Tag Version (push) Successful in 14s Details Build / Publish Documentation (push) Successful in 53s Details	2025-05-11 11:50:08 -04:00
ztimson	26cc18ffb3	Fixed path event, renamed testCondition to logicTest & fixed some tests Some checks failed Build / Build NPM Project (push) Failing after 44s Details Build / Publish Documentation (push) Has been skipped Details Build / Tag Version (push) Has been skipped Details	2025-05-11 11:46:03 -04:00