@zxncij2390/monorepo3 3.18.0

package/packages/core/moments.ts

@@ -0,0 +1,117 @@
+import { ObserverAction, ObserverFunction, Timeline } from "./timeline.js";
+import { isArray } from "./util.js";
+
+/**
+ * Emits to all registered observers the supplied arguments. Any values returned by the observers are ignored
+ *
+ * @returns void
+ */
+export function broadcast<T extends ObserverAction>(): (observers: T[], ...args: any[]) => void {
+
+    return function (observers: T[], ...args: any[]): void {
+
+        const obs = [...observers];
+
+        for (let i = 0; i < obs.length; i++) {
+            Reflect.apply(obs[i], this, args);
+        }
+    };
+}
+
+/**
+ * Defines a moment that executes each observer asynchronously in parallel awaiting all promises to resolve or reject before continuing
+ *
+ * @returns The final set of arguments
+ */
+export function asyncBroadcast<T extends ObserverFunction<void>>(): (observers: T[], ...args: [...Parameters<T>]) => Promise<any[]> {
+
+    return async function (this: Timeline<any>, observers: T[], ...args: [...Parameters<T>]): Promise<any[]> {
+
+        // get our initial values
+        const r = args;
+
+        const obs = [...observers];
+
+        const promises = [];
+
+        for (let i = 0; i < obs.length; i++) {
+            promises.push(Reflect.apply(obs[i], this, r));
+        }
+
+        return Promise.all(promises);
+    };
+}
+
+
+/**
+ * Defines a moment that executes each observer synchronously, passing the returned arguments as the arguments to the next observer.
+ * This is very much like the redux pattern taking the arguments as the state which each observer may modify then returning a new state
+ *
+ * @returns The final set of arguments
+ */
+export function reduce<T extends ObserverFunction<[...Parameters<T>]>>(): (observers: T[], ...args: [...Parameters<T>]) => [...Parameters<T>] {
+
+    return function (this: Timeline<any>, observers: T[], ...args: [...Parameters<T>]): [...Parameters<T>] {
+
+        const obs = [...observers];
+
+        return obs.reduce((params, func: T) => Reflect.apply(func, this, params), args);
+    };
+}
+
+/**
+ * Defines a moment that executes each observer asynchronously, awaiting the result and passes the returned arguments as the arguments to the next observer.
+ * This is very much like the redux pattern taking the arguments as the state which each observer may modify then returning a new state
+ *
+ * @returns The final set of arguments
+ */
+export function asyncReduce<T extends ObserverFunction<[...Parameters<T>]>>(): (observers: T[], ...args: [...Parameters<T>]) => Promise<[...Parameters<T>]> {
+
+    return async function (this: Timeline<any>, observers: T[], ...args: [...Parameters<T>]): Promise<[...Parameters<T>]> {
+
+        const obs = [...observers];
+
+        return obs.reduce((prom, func: T) => prom.then((params) => Reflect.apply(func, this, params)), Promise.resolve(args));
+    };
+}
+
+/**
+ * Defines a moment where the first registered observer is used to asynchronously execute a request, returning a single result
+ * If no result is returned (undefined) no further action is taken and the result will be undefined (i.e. additional observers are not used)
+ *
+ * @returns The result returned by the first registered observer
+ */
+export function request<T extends ObserverFunction>(): (observers: T[], ...args: [...Parameters<T>]) => Promise<ReturnType<T>> {
+
+    return async function (this: Timeline<any>, observers: T[], ...args: [...Parameters<T>]): Promise<ReturnType<T>> {
+
+        if (!isArray(observers) || observers.length < 1) {
+            return undefined;
+        }
+
+        const handler = observers[0];
+
+        return Reflect.apply(handler, this, args);
+    };
+}
+
+/**
+ * Defines a special moment used to configure the timeline itself before starting. Each observer is executed in order,
+ * possibly modifying the "this" instance, with the final product returned
+ *
+ */
+export function lifecycle<T extends ObserverAction>(): (observers: T[], ...args: [...Parameters<T>]) => Timeline<any> {
+
+    return function (this: Timeline<any>, observers: T[], ...args: [...Parameters<T>]): Timeline<any> {
+
+        const obs = [...observers];
+
+        // process each handler which updates our instance in order
+        // very similar to asyncReduce but the state is the object itself
+        for (let i = 0; i < obs.length; i++) {
+            Reflect.apply(obs[i], this, args);
+        }
+
+        return this;
+    };
+}

package/packages/core/package.json

@@ -0,0 +1,10 @@
+{
+    "name": "@pnp/core",
+    "version": "0.0.0-PLACEHOLDER",
+    "description": "pnp - provides shared functionality across all pnp libraries",
+    "main": "./index.js",
+    "typings": "./index",
+    "dependencies": {
+        "tslib": "2.4.1"
+    }
+}

package/packages/core/storage.ts

@@ -0,0 +1,274 @@
+import { dateAdd, jsS, objectDefinedNotNull } from "./util.js";
+
+let storageShim: MemoryStorage | undefined;
+
+function getStorageShim(): MemoryStorage {
+    if (typeof storageShim === "undefined") {
+        storageShim = new MemoryStorage();
+    }
+    return storageShim;
+}
+
+/**
+ * A wrapper class to provide a consistent interface to browser based storage
+ *
+ */
+export class PnPClientStorageWrapper implements IPnPClientStore {
+
+    /**
+     * True if the wrapped storage is available; otherwise, false
+     */
+    public enabled: boolean;
+
+    /**
+     * Creates a new instance of the PnPClientStorageWrapper class
+     *
+     * @constructor
+     */
+    constructor(private store: Storage) {
+
+        this.enabled = this.test();
+    }
+
+    /**
+     * Get a value from storage, or null if that value does not exist
+     *
+     * @param key The key whose value we want to retrieve
+     */
+    public get<T>(key: string): T | null {
+
+        if (!this.enabled) {
+            return null;
+        }
+
+        const o = this.store.getItem(key);
+
+        if (!objectDefinedNotNull(o)) {
+            return null;
+        }
+
+        const persistable = JSON.parse(o);
+
+        if (new Date(persistable.expiration) <= new Date()) {
+            this.delete(key);
+            return null;
+
+        } else {
+
+            return persistable.value as T;
+        }
+    }
+
+    /**
+     * Adds a value to the underlying storage
+     *
+     * @param key The key to use when storing the provided value
+     * @param o The value to store
+     * @param expire Optional, if provided the expiration of the item, otherwise the default is used
+     */
+    public put(key: string, o: any, expire?: Date): void {
+        if (this.enabled) {
+            this.store.setItem(key, this.createPersistable(o, expire));
+        }
+    }
+
+    /**
+     * Deletes a value from the underlying storage
+     *
+     * @param key The key of the pair we want to remove from storage
+     */
+    public delete(key: string): void {
+        if (this.enabled) {
+            this.store.removeItem(key);
+        }
+    }
+
+    /**
+     * Gets an item from the underlying storage, or adds it if it does not exist using the supplied getter function
+     *
+     * @param key The key to use when storing the provided value
+     * @param getter A function which will upon execution provide the desired value
+     * @param expire Optional, if provided the expiration of the item, otherwise the default is used
+     */
+    public async getOrPut<T>(key: string, getter: () => Promise<T>, expire?: Date): Promise<T> {
+
+        if (!this.enabled) {
+            return getter();
+        }
+
+        let o = this.get<T>(key);
+
+        if (o === null) {
+            o = await getter();
+            this.put(key, o, expire);
+        }
+
+        return o;
+    }
+
+    /**
+     * Deletes any expired items placed in the store by the pnp library, leaves other items untouched
+     */
+    public async deleteExpired(): Promise<void> {
+
+        if (!this.enabled) {
+            return;
+        }
+
+        for (let i = 0; i < this.store.length; i++) {
+            const key = this.store.key(i);
+            if (key !== null) {
+                // test the stored item to see if we stored it
+                if (/["|']?pnp["|']? ?: ?1/i.test(<string>this.store.getItem(key))) {
+                    // get those items as get will delete from cache if they are expired
+                    await this.get(key);
+                }
+            }
+        }
+    }
+
+    /**
+     * Used to determine if the wrapped storage is available currently
+     */
+    private test(): boolean {
+        const str = "t";
+        try {
+            this.store.setItem(str, str);
+            this.store.removeItem(str);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    /**
+     * Creates the persistable to store
+     */
+    private createPersistable(o: any, expire?: Date): string {
+        if (expire === undefined) {
+
+            expire = dateAdd(new Date(), "minute", 5);
+        }
+
+        return jsS({ pnp: 1, expiration: expire, value: o });
+    }
+}
+
+/**
+ * Interface which defines the operations provided by a client storage object
+ */
+export interface IPnPClientStore {
+    /**
+     * True if the wrapped storage is available; otherwise, false
+     */
+    enabled: boolean;
+
+    /**
+     * Get a value from storage, or null if that value does not exist
+     *
+     * @param key The key whose value we want to retrieve
+     */
+    get(key: string): any;
+
+    /**
+     * Adds a value to the underlying storage
+     *
+     * @param key The key to use when storing the provided value
+     * @param o The value to store
+     * @param expire Optional, if provided the expiration of the item, otherwise the default is used
+     */
+    put(key: string, o: any, expire?: Date): void;
+
+    /**
+     * Deletes a value from the underlying storage
+     *
+     * @param key The key of the pair we want to remove from storage
+     */
+    delete(key: string): void;
+
+    /**
+     * Gets an item from the underlying storage, or adds it if it does not exist using the supplied getter function
+     *
+     * @param key The key to use when storing the provided value
+     * @param getter A function which will upon execution provide the desired value
+     * @param expire Optional, if provided the expiration of the item, otherwise the default is used
+     */
+    getOrPut<T>(key: string, getter: () => Promise<T>, expire?: Date): Promise<T>;
+
+    /**
+     * Removes any expired items placed in the store by the pnp library, leaves other items untouched
+     */
+    deleteExpired(): Promise<void>;
+}
+
+/**
+ * A thin implementation of in-memory storage for use in nodejs
+ */
+class MemoryStorage {
+
+    constructor(private _store = new Map<string, any>()) { }
+
+    [key: string]: any;
+    [index: number]: string;
+
+    public get length(): number {
+        return this._store.size;
+    }
+
+    public clear(): void {
+        this._store.clear();
+    }
+
+    public getItem(key: string): any {
+        return this._store.get(key);
+    }
+
+    public key(index: number): string {
+        return Array.from(this._store)[index][0];
+    }
+
+    public removeItem(key: string): void {
+        this._store.delete(key);
+    }
+
+    public setItem(key: string, data: string): void {
+        this._store.set(key, data);
+    }
+}
+
+/**
+ * A class that will establish wrappers for both local and session storage, substituting basic memory storage for nodejs
+ */
+export class PnPClientStorage {
+
+    /**
+     * Creates a new instance of the PnPClientStorage class
+     *
+     * @constructor
+     */
+    constructor(private _local: IPnPClientStore | null = null, private _session: IPnPClientStore | null = null) { }
+
+    /**
+     * Provides access to the local storage of the browser
+     */
+    public get local(): IPnPClientStore {
+
+        if (this._local === null) {
+            this._local = new PnPClientStorageWrapper(typeof localStorage === "undefined" ? getStorageShim() : localStorage);
+        }
+
+        return this._local;
+    }
+
+    /**
+     * Provides access to the session storage of the browser
+     */
+    public get session(): IPnPClientStore {
+
+        if (this._session === null) {
+            this._session = new PnPClientStorageWrapper(typeof sessionStorage === "undefined" ? getStorageShim() : sessionStorage);
+        }
+
+        return this._session;
+    }
+}