@netless/window-manager 1.0.0-canary.52 → 1.0.0-canary.54

package/src/App/Storage/index.ts

@@ -1,295 +0,0 @@
-import type { AkkoObjectUpdatedProperty } from "white-web-sdk";
-import { get, has, mapValues, isObject, size, noop } from "lodash";
-import { SideEffectManager } from "side-effect-manager";
-import type { AppContext } from "../AppContext";
-import { safeListenPropsUpdated } from "../../Utils/Reactive";
-import { isRef, makeRef, plainObjectKeys } from "./utils";
-import type { Diff, MaybeRefValue, RefValue, StorageStateChangedEvent, StorageStateChangedListener, StorageStateChangedListenerDisposer } from "./typings";
-import { StorageEvent } from "./StorageEvent";
-
-export * from './typings';
-
-export const STORAGE_NS = "_WM-STORAGE_";
-
-export class Storage<TState extends Record<string, any> = any> implements Storage<TState> {
-  readonly id: string | null;
-
-  private readonly _context: AppContext;
-  private readonly _sideEffect = new SideEffectManager();
-  private _state: TState;
-  private _destroyed = false;
-
-  private _refMap = new WeakMap<any, RefValue>();
-
-  /**
-   * `setState` alters local state immediately before sending to server. This will cache the old value for onStateChanged diffing.
-   */
-  private _lastValue = new Map<string | number | symbol, TState[Extract<keyof TState, string>]>();
-
-  constructor(context: AppContext, id?: string, defaultState?: TState) {
-    if (defaultState && !isObject(defaultState)) {
-      throw new Error(`Default state for Storage ${id} is not an object.`);
-    }
-
-    this._context = context;
-    this.id = id || null;
-
-    this._state = {} as TState;
-    const rawState = this._getRawState(this._state);
-
-    if (this._context.isWritable) {
-      if (this.id === null) {
-        if (context.isAddApp && defaultState) {
-            this.setState(defaultState);
-        }
-      } else {
-        if (rawState === this._state || !isObject(rawState)) {
-          if (!get(this._context.getAttributes(), [STORAGE_NS])) {
-            this._context.updateAttributes([STORAGE_NS], {});
-          }
-          this._context.updateAttributes([STORAGE_NS, this.id], this._state);
-          if (defaultState) {
-            this.setState(defaultState);
-          }
-        }
-      }
-    }
-
-    // strip mobx
-    plainObjectKeys(rawState).forEach(key => {
-      if (this.id === null && key === STORAGE_NS) {
-        return;
-      }
-      try {
-        const rawValue = isObject(rawState[key]) ? JSON.parse(JSON.stringify(rawState[key])) : rawState[key];
-        if (isRef<TState[Extract<keyof TState, string>]>(rawValue)) {
-          this._state[key] = rawValue.v;
-          if (isObject(rawValue.v)) {
-            this._refMap.set(rawValue.v, rawValue);
-          }
-        } else {
-          this._state[key] = rawValue;
-        }
-      } catch (e) {
-        console.error(e);
-      }
-    });
-
-    this._sideEffect.addDisposer(
-      safeListenPropsUpdated(
-        () => this.id === null ? context.getAttributes() : get(context.getAttributes(), [STORAGE_NS, this.id]),
-        this._updateProperties.bind(this),
-        this.destroy.bind(this)
-      )
-    );
-  }
-
-  get state(): Readonly<TState> {
-    if (this._destroyed) {
-      console.warn(`Accessing state on destroyed Storage "${this.id}"`)
-    }
-    return this._state;
-  }
-
-  readonly onStateChanged = new StorageEvent<StorageStateChangedEvent<TState>>();
-  
-  addStateChangedListener(handler: StorageStateChangedListener<TState>): StorageStateChangedListenerDisposer {
-    this.onStateChanged.addListener(handler);
-    return () => this.onStateChanged.removeListener(handler);
-  }
-
-  ensureState(state: Partial<TState>): void {
-    return this.setState(
-      plainObjectKeys(state).reduce((payload, key) => {
-        if (!has(this._state, key)) {
-          payload[key] = state[key];
-        }
-        return payload;
-      }, {} as Partial<TState>)
-    );
-  }
-
-  setState(state: Partial<TState>): void {
-    if (this._destroyed) {
-      console.error(new Error(`Cannot call setState on destroyed Storage "${this.id}".`));
-      return;
-    }
-
-    if (!this._context.isWritable) {
-      console.error(new Error(`Cannot setState on Storage "${this.id}" without writable access`), state);
-      return;
-    }
-
-    const keys = plainObjectKeys(state);
-    if (keys.length > 0) {
-      keys.forEach(key => {
-        const value = state[key];
-        if (value === this._state[key]) {
-          return;
-        }
-
-        if (value === void 0) {
-          this._lastValue.set(key, this._state[key]);
-          delete this._state[key];
-          this._setRawState(key, value);
-        } else {
-          this._lastValue.set(key, this._state[key]);
-          this._state[key] = value as TState[Extract<keyof TState, string>];
-
-          let payload: MaybeRefValue<typeof value> = value;
-          if (isObject(value)) {
-            let refValue = this._refMap.get(value);
-            if (!refValue) {
-              refValue = makeRef(value);
-              this._refMap.set(value, refValue);
-            }
-            payload = refValue;
-          }
-
-          this._setRawState(key, payload)
-        }
-      });
-    }
-  }
-
-  /**
-   * Empty storage data.
-   */
-  emptyStorage(): void {
-    if (size(this._state) <= 0) {
-      return;
-    }
-
-    if (this._destroyed) {
-      console.error(new Error(`Cannot empty destroyed Storage "${this.id}".`));
-      return;
-    }
-
-    if (!this._context.isWritable) {
-      console.error(new Error(`Cannot empty Storage "${this.id}" without writable access.`));
-      return;
-    }
-
-    this.setState(mapValues(this._state, noop as () => undefined));
-  }
-
-  /**
-   * Delete storage index with all of its data and destroy the Storage instance.
-   */
-  deleteStorage(): void {
-    if (this.id === null) {
-      throw new Error(`Cannot delete main Storage`);
-    }
-
-    if (!this._context.isWritable) {
-      console.error(new Error(`Cannot delete Storage "${this.id}" without writable access.`));
-      return;
-    }
-
-    this.destroy();
-
-    this._context.updateAttributes([STORAGE_NS, this.id], void 0);
-  }
-
-  get destroyed(): boolean {
-    return this._destroyed;
-  }
-
-  /**
-   * Destroy the Storage instance. The data will be kept.
-   */
-  destroy() {
-    this._destroyed = true;
-    this._sideEffect.flushAll();
-  }
-
-  private _getRawState(): TState | undefined
-  private _getRawState(defaultValue: TState): TState
-  private _getRawState(defaultValue?: TState): TState | undefined {
-    if (this.id === null) {
-      return this._context.getAttributes() ?? defaultValue;
-    } else {
-      return get(this._context.getAttributes(), [STORAGE_NS, this.id], defaultValue);
-    }
-  }
-
-  private _setRawState(key: string, value: any): void {
-    if (this.id === null) {
-      if (key === STORAGE_NS) {
-        throw new Error(`Cannot set attribute internal filed "${STORAGE_NS}"`)
-      }
-      return this._context.updateAttributes([key], value);
-    } else {
-      return this._context.updateAttributes([STORAGE_NS, this.id, key], value);
-    }
-  }
-
-  private _updateProperties(actions: ReadonlyArray<AkkoObjectUpdatedProperty<TState, string>>): void {
-    if (this._destroyed) {
-      console.error(new Error(`Cannot call _updateProperties on destroyed Storage "${this.id}".`));
-      return;
-    }
-
-    if (actions.length > 0) {
-      const diffs: Diff<TState> = {};
-
-      for (let i = 0; i < actions.length; i++) {
-        try {
-          const action = actions[i]
-          const key = action.key as Extract<keyof TState, string>;
-
-          if (this.id === null && key === STORAGE_NS) {
-            continue
-          }
-
-          const value = isObject(action.value) ? JSON.parse(JSON.stringify(action.value)) : action.value;
-          let oldValue: TState[Extract<keyof TState, string>] | undefined;
-          if (this._lastValue.has(key)) {
-            oldValue = this._lastValue.get(key);
-            this._lastValue.delete(key);
-          }
-
-          switch (action.kind) {
-            case 2: {
-              // Removed
-              if (has(this._state, key)) {
-                oldValue = this._state[key];
-                delete this._state[key];
-              }
-              diffs[key] = { oldValue };
-              break;
-            }
-            default: {
-              let newValue = value;
-
-              if (isRef<TState[Extract<keyof TState, string>]>(value)) {
-                const { k, v } = value;
-                const curValue = this._state[key];
-                if (isObject(curValue) && this._refMap.get(curValue)?.k === k) {
-                  newValue = curValue;
-                } else {
-                  newValue = v;
-                  if (isObject(v)) {
-                    this._refMap.set(v, value);
-                  }
-                }
-              }
-
-              if (newValue !== this._state[key]) {
-                oldValue = this._state[key];
-                this._state[key] = newValue;
-              }
-
-              diffs[key] = { newValue, oldValue };
-              break;
-            }
-          }
-        } catch (e) {
-          console.error(e)
-        }
-      }
-
-      this.onStateChanged.dispatch(diffs);
-    }
-  }
-}

package/src/App/Storage/typings.ts

@@ -1,23 +0,0 @@
-import type { StorageEventListener } from "./StorageEvent";
-
-export type RefValue<TValue = any> = { k: string; v: TValue; __isRef: true };
-
-export type ExtractRawValue<TValue> = TValue extends RefValue<infer TRefValue> ? TRefValue : TValue;
-
-export type AutoRefValue<TValue> = RefValue<ExtractRawValue<TValue>>;
-
-export type MaybeRefValue<TValue> = TValue | AutoRefValue<TValue>;
-
-export type DiffOne<T> = { oldValue?: T; newValue?: T };
-
-export type Diff<T> = { [K in keyof T]?: DiffOne<T[K]> };
-
-export type StorageOnSetStatePayload<TState = unknown> = {
-  [K in keyof TState]?: MaybeRefValue<TState[K]>;
-};
-
-export type StorageStateChangedEvent<TState = any> = Diff<TState>;
-
-export type StorageStateChangedListener<TState = any> = StorageEventListener<StorageStateChangedEvent<TState>>;
-
-export type StorageStateChangedListenerDisposer = () => void;

package/src/App/Storage/utils.ts

@@ -1,17 +0,0 @@
-import { has } from "lodash";
-import { genUID } from "side-effect-manager";
-import type { AutoRefValue, ExtractRawValue, RefValue } from "./typings";
-
-export const plainObjectKeys = Object.keys as <T>(o: T) => Array<Extract<keyof T, string>>;
-
-export function isRef<TValue = unknown>(e: unknown): e is RefValue<TValue> {
-  return Boolean(has(e, '__isRef'));
-}
-
-export function makeRef<TValue>(v: TValue): RefValue<TValue> {
-  return { k: genUID(), v, __isRef: true };
-}
-
-export function makeAutoRef<TValue>(v: TValue): AutoRefValue<TValue> {
-  return isRef<ExtractRawValue<TValue>>(v) ? v : makeRef(v as ExtractRawValue<TValue>);
-}