@fireflysemantics/slice 14.0.7

package/lib/EStore.d.ts

@@ -0,0 +1,403 @@
+import { AbstractStore } from './AbstractStore';
+import { StoreConfig } from './models/StoreConfig';
+import { Predicate, Delta } from './models/';
+import { Observable } from 'rxjs';
+import { Slice } from './Slice';
+/**
+ * This `todoFactory` code will be used to illustrate the API examples.  The following
+ * utilities are used in the tests and the API Typedoc examples contained here.
+ * @example Utilities for API Examples
+```
+export const enum TodoSliceEnum {
+  COMPLETE = "Complete",
+  INCOMPLETE = "Incomplete"
+}
+
+export class Todo {
+  constructor(public complete: boolean, public title: string,public gid?:string, public id?:string) {}
+}
+
+export let todos = [new Todo(false, "You complete me!"), new Todo(true, "You completed me!")];
+
+export function todosFactory():Todo[] {
+  return [new Todo(false, "You complete me!"), new Todo(true, "You completed me!")];
+}
+ ```
+ */
+export declare class EStore<E> extends AbstractStore<E> {
+    /**
+     * Store constructor (Initialization with element is optional)
+     *
+     * perform initial notification to all observers,
+     * such that function like {@link combineLatest}{}
+     * will execute at least once.
+     * @param entities
+     * @example Dynamic `EStore<Todo>` Creation
+  ```
+  // Initialize the Store
+  let store: EStore<Todo> = new EStore<Todo>(todosFactory());
+  ```*/
+    constructor(entities?: E[], config?: StoreConfig);
+    /**
+     * Calls complete on all {@link BehaviorSubject} instances.
+     *
+     * Call destroy when disposing of the store.
+     */
+    destroy(): void;
+    /**
+     * Toggles the entity:
+     *
+     * If the store contains the entity
+     * it will be deleted.  If the store
+     * does not contains the entity,
+     * it is added.
+     * @param e
+     * @example Toggle the `Todo` instance
+  ```
+  estore.post(todo);
+  // Remove todo
+  estore.toggle(todo);
+  // Add it back
+  estore.toggle(todo);
+  
+  ```
+     */
+    toggle(e: E): void;
+    /**
+     * An Observable<E[]> reference so that
+     *
+     */
+    observable: Observable<E[]>;
+    /**
+     * Notifies observers when the store is empty.
+     */
+    private notifyActive;
+    /**
+     * `Map` of active entties. The instance is public and can be used
+     * directly to add and remove active entities, however we recommend
+     * using the {@link addActive} and {@link deleteActive} methods.
+     */
+    active: Map<string, E>;
+    /**
+     * Add multiple entity entities to active.
+     *
+     * If the entity is not contained in the store it is added
+     * to the store before it is added to `active`.
+     *
+     * Also we clone the map prior to broadcasting it with
+     * `notifyActive` to make sure we will trigger Angular
+     * change detection in the event that it maintains
+     * a reference to the `active` state `Map` instance.
+     *
+     * @example Add a `todo1` and `todo2` as active
+  ```
+  addActive(todo1);
+  addActive(todo2);
+  ```
+     */
+    addActive(e: E): void;
+    /**
+     * Delete an entity as active.
+     *
+     * Also we clone the map prior to broadcasting it with
+     * `notifyActive` to make sure we will trigger Angular
+     * change detection in the event that it maintains
+     * a reference to the `active` state `Map` instance.
+     *
+     * @example Mark a `todo` instance as active
+    ```
+  deleteActive(todo1);
+  deleteActive(todo2);
+    ```
+     */
+    deleteActive(e: E): void;
+    /**
+     * Clear / reset the active entity map.
+     *
+     * Also we clone the map prior to broadcasting it with
+     * `notifyActive` to make sure we will trigger Angular
+     * change detection in the event that it maintains
+     * a reference to the `active` state `Map` instance.
+     *
+     * @example Mark a `todo` instance as active
+    ```
+  deleteActive(todo1);
+  deleteActive(todo2);
+    ```
+     */
+    clearActive(): void;
+    /**
+     * Observe the active entity.
+     * @example
+       <pre>
+      let active$ = source.observeActive();
+      </pre>
+    */
+    observeActive(): Observable<Map<string, E>>;
+    /**
+     * Observable of errors occurred during a load request.
+     *
+     * The error Observable should be created by the
+     * client.
+     */
+    loadingError: Observable<any>;
+    /**
+     * Notifies observers when the store is loading.
+     *
+     * This is a common pattern found when implementing
+     * `Observable` data sources.
+     */
+    private notifyLoading;
+    /**
+     * The current loading state.  Use loading when fetching new
+     * data for the store.  The default loading state is `true`.
+     *
+     * This is such that if data is fetched asynchronously
+     * in a service, components can wait on loading notification
+     * before attempting to retrieve data from the service.
+     *
+     * Loading could be based on a composite response.  For example
+     * when the stock and mutual funds have loaded, set loading to `false`.
+     */
+    private _loading;
+    /**
+     * Sets the current loading state and notifies observers.
+     */
+    set loading(loading: boolean);
+    /**
+     * @return A snapshot of the loading state.
+     */
+    get loading(): boolean;
+    /**
+     * Observe loading.
+     * @example
+       <pre>
+      let loading$ = source.observeLoading();
+      </pre>
+  
+      Note that this obverable piped through
+      `takeWhile(v->v, true), such that it will
+      complete after each emission.
+  
+      See:
+      https://medium.com/@ole.ersoy/waiting-on-estore-to-load-8dcbe161613c
+  
+      For more details.
+    */
+    observeLoading(): Observable<boolean>;
+    /**
+     * Notfiies when loading has completed.
+     */
+    observeLoadingComplete(): Observable<boolean>;
+    /**
+     * Observable of errors occurred during a search request.
+     *
+     * The error Observable should be created by the
+     * client.
+     */
+    searchError: Observable<any>;
+    /**
+     * Notifies observers that a search is in progress.
+     *
+     * This is a common pattern found when implementing
+     * `Observable` data sources.
+     */
+    private notifySearching;
+    /**
+     * The current `searching` state.  Use `searching`
+     * for example to display a spinnner
+     * when performing a search.
+     * The default `searching` state is `false`.
+     */
+    private _searching;
+    /**
+     * Sets the current searching state and notifies observers.
+     */
+    set searching(searching: boolean);
+    /**
+     * @return A snapshot of the searching state.
+     */
+    get searching(): boolean;
+    /**
+     * Observe searching.
+     * @example
+       <pre>
+      let searching$ = source.observeSearching();
+      </pre>
+    
+      Note that this obverable piped through
+      `takeWhile(v->v, true), such that it will
+      complete after each emission.
+    
+      See:
+      https://medium.com/@ole.ersoy/waiting-on-estore-to-load-8dcbe161613c
+    
+      For more details.
+    */
+    observeSearching(): Observable<boolean>;
+    /**
+     * Notfiies when searching has completed.
+     */
+    observeSearchingComplete(): Observable<boolean>;
+    /**
+     * Store slices
+     */
+    private slices;
+    /**
+     * Adds a slice to the store and keys it by the slices label.
+     *
+     * @param p
+     * @param label
+     *
+     * @example Setup a Todo Slice for COMPLETE Todos
+  ```
+  source.addSlice(todo => todo.complete, TodoSlices.COMPLETE);
+  ```
+     */
+    addSlice(p: Predicate<E>, label: string): void;
+    /**
+     * Remove a slice
+     * @param label The label identifying the slice
+     *
+     * @example Remove the TodoSlices.COMPLETE Slice
+  ```
+  source.removeSlice(TodoSlices.COMPLETE);
+  ```
+     */
+    removeSlice(label: string): void;
+    /**
+     * Get a slice
+     * @param label The label identifying the slice
+     * @return The Slice instance or undefined
+     *
+     * @example Get the TodoSlices.COMPLETE slice
+  ```
+  source.getSlice(TodoSlices.COMPLETE);
+  ```
+     */
+    getSlice(label: string): Slice<E> | undefined;
+    /**
+     * Post (Add a new) element(s) to the store.
+     * @param e An indiidual entity or an array of entities
+     * @example Post a `todo`.
+  ```
+  store.post(todo);
+  ```
+     */
+    post(e: E | E[]): void;
+    /**
+     * Post elements to the store.
+     * @param ...e
+     * @example Post two `Todo` instances.
+  ```
+  store.post(todo1, todo2);
+  ```
+     */
+    postN(...e: E[]): void;
+    /**
+     * Post (Add) an array of elements to the store.
+     * @param e
+     * @example Post a `Todo` array.
+  ```
+  store.post([todo1, todo2]);
+  ```
+     */
+    postA(e: E[]): void;
+    /**
+     * Put (Update) an element.
+     * @param e
+     * @example Put a Todo instance.
+  ```
+  store.put(todo1);
+  ```
+     */
+    put(e: E | E[]): void;
+    /**
+     * Put (Update) an element or add an element that was read from a persistence source
+     * and thus already has an assigned global id`.
+     * @param e
+     * @example Put Todo instances.
+  ```
+  store.put(todo1, todo2);
+  ```
+     */
+    putN(...e: E[]): void;
+    /**
+     * Put (Update) the array of elements.
+     * @param e
+     * @example Put Todo instances.
+  ```
+  store.put([todo1, todo2]);
+  ```
+     */
+    putA(e: E[]): void;
+    /**
+     * Delete (Update) the array of elements.
+     * @param e
+     * @example Delete todo1.
+  ```
+  store.delete(todo1]);
+  ```
+     */
+    delete(e: E | E[]): void;
+    /**
+     * Delete N elements.
+     * @param ...e
+     * @example Put Todo instances.
+  ```
+  store.delete(todo1, todo2);
+  ```
+     */
+    deleteN(...e: E[]): void;
+    /**
+     * Delete N elements.
+     * @param ...e
+     * @example Put Todo instances.
+  ```
+  store.delete(todo1, todo2);
+  ```
+     */
+    deleteA(e: E[]): void;
+    /**
+     * Delete elements by {@link Predicate}.
+     * @param p The predicate.
+     * @example Put Todo instances.
+  ```
+  store.delete(todo1, todo2);
+  ```
+     */
+    deleteP(p: Predicate<E>): void;
+    /**
+     * If the entity has the `id` key initialized with a value,
+     * then also add the entity to the `idEntries`.
+     *
+     * @param e The element to be added to the `idEntries`.
+     */
+    private updateIDEntry;
+    /**
+     * If the entity has the `id` key initialized with a value,
+     * then also delete the entity to the `idEntries`.
+     *
+     * @param e The element to be added to the `idEntries`.
+     */
+    private deleteIDEntry;
+    /**
+     * Resets the store and all contained slice instances to empty.
+     * Also perform delta notification that sends all current store entries.
+     * The ActionType.RESET code is sent with the delta notification.  Slices
+     * send their own delta notification.
+     *
+     * @example Reset the store.
+  ```
+  store.reset();
+  ```
+     */
+    reset(): void;
+    /**
+     * Call all the notifiers at once.
+     *
+     * @param v
+     * @param delta
+     */
+    protected notifyAll(v: E[], delta: Delta<E>): void;
+}

package/lib/OStore.d.ts

@@ -0,0 +1,106 @@
+import { Observable } from 'rxjs';
+/**
+ * Initialize hte store with this.
+ */
+export interface ValueReset {
+    value: any;
+    reset?: any;
+}
+/**
+ * OStore Key Value Reset
+ */
+export interface ObsValueReset {
+    value: any;
+    reset?: any;
+    obs: Observable<any>;
+}
+export interface KeyObsValueReset {
+    [key: string]: ObsValueReset;
+}
+export interface OStoreStart {
+    [key: string]: ValueReset;
+}
+export declare class OStore<E extends KeyObsValueReset> {
+    /**
+     * Start keys and values
+     * passed in via constructor.
+     */
+    S: E;
+    constructor(start: OStoreStart);
+    /**
+     * Reset the state of the OStore to the
+     * values or reset provided in the constructor
+     * {@link OStoreStart} instance.
+     */
+    reset(): void;
+    /**
+     * Clear all entries
+     */
+    clear(): void;
+    /**
+     * Map of Key Value pair entries
+     * containing values store in this store.
+     */
+    entries: Map<any, any>;
+    /**
+     * Map of replay subject id to `ReplaySubject` instance.
+     */
+    private subjects;
+    /**
+     * Set create a key value pair entry and creates a
+     * corresponding replay subject instance that will
+     * be used to broadcast updates.
+     *
+     * @param key The key identifying the value
+     * @param value The value
+     */
+    post(key: any, value: any): void;
+    /**
+     * Update a value and notify subscribers.
+     *
+     * @param key
+     * @param value
+     */
+    put(key: any, value: any): void;
+    /**
+     * Deletes both the value entry and the corresponding {@link ReplaySubject}.
+     * Will unsubscribe the {@link ReplaySubject} prior to deleting it,
+     * severing communication with corresponding {@link Observable}s.
+     *
+     * @param key
+     */
+    delete(key: any): void;
+    /**
+     * Observe changes to the values.
+     *
+     * @param key
+     * @return An {@link Observable} of the value
+     */
+    observe(key: any): Observable<any>;
+    /**
+      * Check whether a value exists.
+      *
+      * @param key
+      * @return True if the entry exists ( Is not null or undefined ) and false otherwise.
+      */
+    exists(key: any): boolean;
+    /**
+     * Retrieve a snapshot of the
+     * value.
+     *
+     * @param key
+     * @return A snapshot of the value corresponding to the key.
+     */
+    snapshot(key: any): any;
+    /**
+     * Indicates whether the store is empty.
+     * @return true if the store is empty, false otherwise.
+     */
+    isEmpty(): boolean;
+    /**
+     * Returns the number of key value pairs contained.
+     *
+     * @return the number of entries in the store.
+     */
+    count(): number;
+}

package/lib/Slice.d.ts

@@ -0,0 +1,97 @@
+import { Predicate } from "./models";
+import { AbstractStore } from "./AbstractStore";
+import { EStore } from "./EStore";
+export declare class Slice<E> extends AbstractStore<E> {
+    label: string;
+    predicate: Predicate<E>;
+    eStore: EStore<E>;
+    entries: Map<string, E>;
+    /**
+     * perform initial notification to all observers,
+     * such that operations like {@link combineLatest}{}
+     * will execute at least once.
+     *
+     * @param label The slice label
+     * @param predicate The slice predicate
+     * @param eStore The EStore instance containing the elements considered for slicing
+     *
+     * @example
+       <pre>
+       //Empty slice
+       new Slice<Todo>(Todo.COMPLETE, todo=>!todo.complete);
+  
+       //Initialized slice
+       let todos = [new Todo(false, "You complete me!"),
+                    new Todo(true, "You completed me!")];
+       new Slice<Todo>(Todo.COMPLETE, todo=>!todo.complete, todos);
+       </pre>
+     */
+    constructor(label: string, predicate: Predicate<E>, eStore: EStore<E>);
+    /**
+     * Add the element if it satisfies the predicate
+     * and notify subscribers that an element was added.
+     *
+     * @param e The element to be considered for slicing
+     */
+    post(e: E | E[]): void;
+    /**
+     * Add the elements if they satisfy the predicate
+     * and notify subscribers that elements were added.
+     *
+     * @param e The element to be considered for slicing
+     */
+    postN(...e: E[]): void;
+    /**
+     * Add the elements if they satisfy the predicate
+     * and notify subscribers that elements were added.
+     *
+     * @param e The element to be considered for slicing
+     */
+    postA(e: E[]): void;
+    /**
+     * Delete an element from the slice.
+     *
+     * @param e The element to be deleted if it satisfies the predicate
+     */
+    delete(e: E | E[]): void;
+    /**
+     * @param e The elements to be deleted if it satisfies the predicate
+     */
+    deleteN(...e: E[]): void;
+    /**
+     * @param e The elements to be deleted if they satisfy the predicate
+     */
+    deleteA(e: E[]): void;
+    /**
+     * Update the slice when an Entity instance mutates.
+     *
+     * @param e The element to be added or deleted depending on predicate reevaluation
+     */
+    put(e: E | E[]): void;
+    /**
+     * Update the slice with mutated Entity instances.
+     *
+     * @param e The elements to be deleted if it satisfies the predicate
+     */
+    putN(...e: E[]): void;
+    /**
+     * @param e The elements to be put
+     */
+    putA(e: E[]): void;
+    /**
+     * Resets the slice to empty.
+     */
+    reset(): void;
+    /**
+     * Utility method that applies the predicate to an array
+     * of entities and return the ones that pass the test.
+     *
+     * Used to create an initial set of values
+     * that should be part of the `Slice`.
+     *
+     * @param p
+     * @param e
+     * @return The the array of entities that pass the predicate test.
+     */
+    test(p: Predicate<E>, e: E[]): E[];
+}

package/lib/models/ActionTypes.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The action types for the store.
+ */
+export declare const enum ActionTypes {
+    POST = "Post",
+    PUT = "Put",
+    DELETE = "Delete",
+    INTIALIZE = "Initialize",
+    RESET = "Reset"
+}

package/lib/models/Delta.d.ts

@@ -0,0 +1,10 @@
+import { ActionTypes } from "./ActionTypes";
+/**
+ * Delta update interface models
+ * the type of the update and the entities
+ * associated with the update.
+ */
+export interface Delta<E> {
+    type: ActionTypes;
+    entries: E[];
+}

package/lib/models/Predicate.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Function type for predicate operations
+ */
+export declare type Predicate<E> = (e: E) => boolean;

package/lib/models/StoreConfig.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The configuration interface for the entity store
+ * defines the strings for the ID Key and Global ID key.
+ */
+export interface StoreConfig {
+    idKey: string;
+    guidKey: string;
+}

package/lib/models/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ActionTypes';
+export * from './Delta';
+export * from './Predicate';
+export * from './StoreConfig';

package/lib/models/scrollPosition.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Scroll position function type used to auto hide
+ * the material toolbar in conjuction with Angular CDK.
+ */
+export declare type scrollPosition = () => [number, number];