initial work on next moize superset

Author: planttheidea

DEV_ONLY/moize-next/Cache.ts

@@ -0,0 +1,198 @@
+import { Cache as BaseCache, CacheEvent, CacheEventReason, CacheNode, Key, KeyTransformer } from '../../src';
+import type { NormalizedOptions, Options, StatsProfile } from './internalTypes';
+import { defaultArgumentSerializer, isSerializedKeyEqual } from './serialize';
+import { clearStats, getStats } from './stats';
+import { cloneKey, compose, getMaxArgsTransformKey } from './utils';
+
+export interface ExpirationManager {
+    a: boolean;
+    c: () => void;
+    e: () => void;
+    i: ReturnType<typeof setTimeout> | null;
+    s: () => void;
+    t: number;
+    u: (newExpiration?: number) => void;
+}
+
+const expiringNodes = new Map<CacheNode<any>, ExpirationManager>();
+
+export class Cache<Fn extends (...args: any[]) => any> extends BaseCache<Fn> {
+    pn: string;
+    s: boolean = false;
+    x?: number;
+    xo?: Options<Fn>['onExpire'];
+    xr?: Options<Fn>['rescheduleExpiration'];
+
+    constructor(options: NormalizedOptions<Fn>) {
+        super(options);
+
+        this.pn = options.profileName;
+
+        const { expiresAfter, maxArgs, serialize, transformKey } = options;
+
+        const keyTransformers: KeyTransformer<Fn>[] = [];
+
+        if (serialize) {
+            if (!options.isKeyEqual) {
+                this.m = isSerializedKeyEqual;
+            }
+
+            keyTransformers.push(
+                typeof serialize === 'function' 
+                    ? (args: IArguments | Key) => serialize(cloneKey<Fn>(args as Parameters<Fn>))
+                    : defaultArgumentSerializer,
+            );
+        }
+
+        if (transformKey) {
+            keyTransformers.push(transformKey);
+        }
+
+        if (maxArgs && maxArgs >= 0) {
+            keyTransformers.push(getMaxArgsTransformKey(maxArgs));
+        }
+
+        if (keyTransformers.length) {
+            // @ts-expect-error - ignore for now
+            this.k = compose(...keyTransformers);
+        }
+
+        if (typeof expiresAfter === 'number' && !isNaN(expiresAfter) && expiresAfter > 0 && expiresAfter < Infinity) {
+            this.x = expiresAfter;
+            this.xo = options.onExpire;
+            this.xr = options.rescheduleExpiration;
+
+            if (this.xr) {
+                this.xu = this.xu.bind(this);
+                
+                this.on('hit', this.xu);
+                this.on('update', this.xu);
+            }
+
+            this.clear = this.xc;
+            this.d = this.xd;
+            this.n = this.xn.bind(this, expiresAfter);
+        }
+    }
+
+    clearStats(): void {
+        clearStats(this.pn);
+    }
+
+    getStats(): StatsProfile {
+        return getStats(this.pn);
+    }
+
+    keys(): Key[] {
+        return this.entries().map((entry) => entry[0]);
+    }
+
+    values(): Array<ReturnType<Fn>> {
+        return this.entries().map((entry) => entry[1]);
+    }
+
+    xc() {
+        expiringNodes.forEach((expiringMananger) => {
+            expiringMananger.c();
+        });
+
+        super.clear();
+    }
+
+    xd(node: CacheNode<Fn>): void {
+        super.d(node);
+
+        const expirationManager = expiringNodes.get(node);
+
+        if (expirationManager) {
+            expirationManager.c();
+            expiringNodes.delete(node);
+        }
+    }
+
+    xm(node: CacheNode<Fn>, expiration: number): ExpirationManager {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const cache = this;
+
+        return {
+            a: false,
+            i: null,
+            t: expiration,
+
+            c() {
+                if (this.i) {
+                    clearTimeout(this.i);
+                    this.i = null;
+                }
+            },
+
+            e() {
+                if (!this.a) {
+                    return;
+                }
+
+                this.c();
+                expiringNodes.delete(node);
+
+                this.a = false;
+                
+                if (cache.xo) {
+                    const result = cache.xo([node.k, node.v]);
+    
+                    if (result === false) {
+                        return;
+                    }
+                }
+    
+                cache.d(node);
+                cache.od && cache.od.n(node, 'expired' as unknown as CacheEventReason);
+            },
+        
+            s() {
+                this.a = true;
+                
+                expiringNodes.set(node, this);
+        
+                this.i = setTimeout(() => {
+                    this.e();
+                    this.i = null;
+                }, this.t);
+            },
+        
+            u(this: ExpirationManager, newExpiration: number = this.t) {
+                this.a && this.c();
+        
+                this.t = newExpiration;
+                this.s();
+            }
+
+        }
+    }
+
+    xn(expiration: number, key: Key, value: any) {
+        const node = super.n(key, value);
+
+        const expirationManager = this.xm(node, expiration);
+
+        expiringNodes.set(node, expirationManager);
+        expirationManager.s();
+
+        return node;
+    }
+
+    xu(event: CacheEvent<'hit' | 'update', Fn>): void {
+        if (typeof this.xr === 'function' && !this.xr(event)) {
+            return;
+        }
+
+        const key = event.entry[0];
+        const node = this.g(key);
+        const expirationManager = node && expiringNodes.get(node);
+
+        if (!expirationManager) {
+            return;
+        }
+
+        expirationManager.u();
+    }
+}

DEV_ONLY/moize-next/environment.ts

@@ -0,0 +1,43 @@
+import 'core-js';
+import 'regenerator-runtime/runtime';
+// import moize from './moize';
+import type { Key, Moized, Options } from './internalTypes';
+
+// moize.collectStats();
+
+export function log(message: string, key: Key, value: any) {
+    console.log(`result (${message})`, key, value);
+}
+
+export function logCache<Fn extends (...args: any[]) => any>(memoized: Moized<Fn, Options<Fn>>) {
+    console.log('cache', memoized.cache.entries());
+}
+
+export function logStoredValue<Fn extends (...args: any[]) => any>(
+    memoized: Moized<Fn, Options<Fn>>,
+    message: number | string,
+    key: Parameters<Fn>
+) {
+    console.log(`result (${message})`, key, memoized.cache.get(key));
+}
+
+export function createContainer() {
+    const div = document.createElement('div');
+
+    div.textContent = 'Check the console for details.';
+
+    div.id = 'app-container';
+    div.style.backgroundColor = '#1d1d1d';
+    div.style.boxSizing = 'border-box';
+    div.style.color = '#d5d5d5';
+    div.style.height = '100vh';
+    div.style.padding = '15px';
+    div.style.width = '100vw';
+
+    document.body.style.margin = '0px';
+    document.body.style.padding = '0px';
+
+    document.body.appendChild(div);
+
+    return div;
+}

DEV_ONLY/moize-next/index.tsx

@@ -0,0 +1,42 @@
+import moize from './moize';
+
+document.body.style.backgroundColor = '#1d1d1d';
+document.body.style.color = '#d5d5d5';
+document.body.style.margin = '0px';
+document.body.style.padding = '0px';
+
+const moized = moize((one: string, two: string, three) => {
+    console.log('called');
+
+    return ({ one, two, three });
+}, { 
+    expiresAfter: 2000,
+    maxArgs: 2,
+    maxSize: 2,
+    onExpire(entry) {
+        console.log('expired', entry[0]);
+    },
+    rescheduleExpiration: true,
+    serialize: true,
+    transformKey(key) {
+        console.log({ key})
+        return [...key].reverse();
+    }
+});
+
+moized.cache.on('delete', (event) => {
+    console.log('deleted', event.cache.oh);
+})
+
+console.log(moized('one', 'two', 'three'));
+console.log(moized('one', 'three', 'two'));
+console.log(moized('two', 'three', 'one'));
+console.log(moized('one', 'two', 'three'));
+console.log(moized('one', 'two', 'three'));
+
+console.log(moized.cache.oh);
+console.log(moized.cache.entries());
+
+moized.cache.delete(['two', 'three', 'bunk']);
+
+console.log(moized.cache.entries())

DEV_ONLY/moize-next/internalTypes.ts

@@ -0,0 +1,108 @@
+
+import type {  
+    CacheEntry, 
+    CacheEvent,
+    Key, 
+    OptionsArgEqual as BaseOptionsArgEqual, 
+    OptionsKeyEqual as BaseOptionsKeyEqual,
+} from '../../src';
+import type { Cache } from './Cache';
+
+export type * from '../../src';
+
+interface OptionsArgEqual<Fn extends (...args: any[]) => any> extends Omit<BaseOptionsArgEqual<Fn>, 'isArgEqual'> {
+    isArgEqual?: 'deep' | 'shallow' | BaseOptionsArgEqual<Fn>['isArgEqual'];
+}
+
+type BaseOptions<Fn extends (...args: any[]) => any> = OptionsArgEqual<Fn> & BaseOptionsKeyEqual<Fn>;
+
+export type Options<Fn extends (...args: any[]) => any> = BaseOptions<Fn> & {
+    expiresAfter?: number;
+    /**
+     * Whether the function is a React component.
+     */
+    maxArgs?: number;
+    onExpire?: (entry: CacheEntry<Fn>) => any;
+    profileName?: string;
+    rescheduleExpiration?: boolean | ((event: CacheEvent<'hit' | 'update', Fn>) => boolean);
+    serialize?: boolean | ((key: Key) => [string]);
+}
+
+export type NormalizedOptions<Fn extends (...args: any[]) => any> = Options<Fn> & {
+    isArgEqual: BaseOptions<Fn>['isArgEqual'];
+    profileName: string;
+};
+
+export interface Moized<
+  Fn extends (...args: any[]) => any,
+  Opts extends Options<Fn>,
+> {
+  (...args: Parameters<Fn>): ReturnType<Fn>;
+
+  /**
+   * The cache used for the memoized method.
+   */
+  cache: Cache<Fn>;
+  /**
+   * The original method that is memoized.
+   */
+  fn: Fn;
+  /**
+   * Simple identifier that the function has been memoized.
+   */
+  isMoized: true;
+  /**
+   * Options passed for the memoized method.
+   */
+  options: Opts;
+}
+
+export interface Moize {
+    <
+        Fn extends Moized<
+        (...args: any[]) => any,
+        Options<(...args: any[]) => any>
+        >,
+        Opts extends Options<Fn['fn']>,
+    >(
+        fn: Fn,
+        passedOptions: Opts,
+    ): Moized<Fn['fn'], Fn['options'] & Opts>;
+    <
+        Fn extends Moized<
+        (...args: any[]) => any,
+        Options<(...args: any[]) => any>
+        >,
+    >(
+        fn: Fn,
+    ): Moized<Fn, Fn['options']>;
+    <Fn extends (...args: any[]) => any, Opts extends Options<Fn>>(
+        fn: Fn,
+        passedOptions: Opts,
+    ): Moized<Fn, Opts>;
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    <Fn extends (...args: any[]) => any>(fn: Fn): Moized<Fn, {}>;
+
+    isMoized: (fn: any) => fn is Moized<any, any>;
+}
+
+export interface StatsCache {
+    anonymousProfileNameCounter: number;
+    isCollectingStats: boolean;
+    profiles: Record<string, StatsProfile>;
+}
+
+export interface StatsObject {
+    calls: number;
+    hits: number;
+    usage: string;
+}
+
+export interface GlobalStatsObject extends StatsObject {
+    profiles?: Record<string, StatsProfile>;
+}
+
+export interface StatsProfile {
+    calls: number;
+    hits: number;
+}