feat(api): unwrap event types

falsandtru · May 1, 2017 · e0b0bc0 · e0b0bc0
1 parent 798bd81
commit e0b0bc0
Show file tree

Hide file tree

Showing 11 changed files with 151 additions and 155 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.13.0
+
+- Unwrap event types.
+
 ## 0.12.0
 
 - Refine APIs.

diff --git a/index.d.ts b/index.d.ts
@@ -3,9 +3,9 @@
 export class StoreChannel<K extends string, V extends StoreChannelObject<K>> {
   constructor(name: string, config: StoreChannelConfig<K, V>);
   readonly events: {
-    readonly load: Observer<never[] | [K] | [K, keyof V | ''] | [K, keyof V | '', StoreChannelEvent.Type], StoreChannelEvent<K, V>, void>,
-    readonly save: Observer<never[] | [K] | [K, keyof V | ''] | [K, keyof V | '', StoreChannelEvent.Type], StoreChannelEvent<K, V>, void>,
-    readonly loss: Observer<never[] | [K] | [K, keyof V | ''] | [K, keyof V | '', StoreChannelEvent.Type], StoreChannelEvent<K, V>, void>
+    readonly load: Observer<never[] | [K] | [K, keyof V | ''] | [K, keyof V | '', StoreChannelEventType], StoreChannelEvent<K, V>, void>,
+    readonly save: Observer<never[] | [K] | [K, keyof V | ''] | [K, keyof V | '', StoreChannelEventType], StoreChannelEvent<K, V>, void>,
+    readonly loss: Observer<never[] | [K] | [K, keyof V | ''] | [K, keyof V | '', StoreChannelEventType], StoreChannelEvent<K, V>, void>
   };
   sync(keys: K[], cb?: (errs: [K, DOMException | DOMError][]) => any): void;
   transaction(key: K, cb: () => any, complete: (err?: DOMException | DOMError | Error) => any): void;
@@ -25,7 +25,7 @@ export interface StoreChannelObject<K extends string> {
   readonly __id: number;
   readonly __key: K;
   readonly __date: number;
-  readonly __event: Observer<[StorageChannelEvent.Type] | [StorageChannelEvent.Type, keyof this | ''], StorageChannelEvent<this>, any>;
+  readonly __event: Observer<[StorageChannelEventType] | [StorageChannelEventType, keyof this | ''], StorageChannelEvent<this>, any>;
   readonly __transaction: (key: K, cb: () => any, complete: (err?: DOMException | DOMError | Error) => any) => void;
 }
 export interface StoreChannelObjectMetaData<K extends string> {
@@ -34,21 +34,19 @@ export interface StoreChannelObjectMetaData<K extends string> {
   readonly date: number;
 }
 export interface StoreChannelEvent<K extends string, V extends StoreChannelObject<K>> {
-  readonly type: StoreChannelEvent.Type;
+  readonly type: StoreChannelEventType;
   readonly id: number;
   readonly key: K;
   readonly attr: keyof V | '';
 }
-export namespace StoreChannelEvent {
-  export type Type
-    = Type.Put
-    | Type.Delete
-    | Type.Snapshot;
-  export namespace Type {
-    export type Put = 'put';
-    export type Delete = 'delete';
-    export type Snapshot = 'snapshot';
-  }
+export type StoreChannelEventType
+  = StoreChannelEventType.Put
+  | StoreChannelEventType.Delete
+  | StoreChannelEventType.Snapshot;
+export namespace StoreChannelEventType {
+  export type Put = 'put';
+  export type Delete = 'delete';
+  export type Snapshot = 'snapshot';
 }
 
 export class StorageChannel<V extends StorageChannelObject> {
@@ -64,20 +62,18 @@ export interface StorageChannelConfig<V extends StorageChannelObject> {
   schema(): V;
 }
 export interface StorageChannelObject {
-  readonly __event: Observer<[StorageChannelEvent.Type] | [StorageChannelEvent.Type, keyof this], StorageChannelEvent<this>, any>;
+  readonly __event: Observer<[StorageChannelEventType] | [StorageChannelEventType, keyof this], StorageChannelEvent<this>, any>;
 }
 export interface StorageChannelEvent<V extends StorageChannelObject> {
-  readonly type: StorageChannelEvent.Type;
+  readonly type: StorageChannelEventType;
   readonly attr: keyof V;
   readonly newValue: V[keyof V];
   readonly oldValue: V[keyof V];
 }
-export namespace StorageChannelEvent {
-  export type Type
-    = Type.Send
-    | Type.Recv;
-  export namespace Type {
-    export type Send = 'send';
-    export type Recv = 'recv';
-  }
+export type StorageChannelEventType
+  = StorageChannelEventType.Send
+  | StorageChannelEventType.Recv;
+export namespace StorageChannelEventType {
+  export type Send = 'send';
+  export type Recv = 'recv';
 }
diff --git a/src/layer/data/schema/event.ts b/src/layer/data/schema/event.ts
@@ -1,4 +1,4 @@
-import { StoreChannelEvent } from '../../../../';
+import { StoreChannelEventType } from '../../../../';
 import { clone } from 'spica';
 import { IdNumber } from '../constraint/types';
 
@@ -12,10 +12,10 @@ export namespace EventRecordFields {
   export const surrogateKeyDateField: 'key+date' = 'key+date';
 }
 
-abstract class EventRecord<K extends string, V extends EventValue> {
+abstract class EventRecord<K extends string, V extends EventRecordValue> {
   constructor(
     public readonly id: IdNumber,
-    public readonly type: EventType,
+    public readonly type: EventRecordType,
     public readonly key: K,
     public readonly value: Partial<V>,
     public readonly date: number,
@@ -26,28 +26,28 @@ abstract class EventRecord<K extends string, V extends EventValue> {
     if (typeof this.value !== 'object' || !this.value) throw new TypeError(`ClientChannel: EventRecord: Invalid event value: ${this.value}`);
     if (typeof this.date !== 'number' || this.date >= 0 === false) throw new TypeError(`ClientChannel: EventRecord: Invalid event date: ${this.date}`);
     // put -> string, delete or snapshot -> empty string
-    this.attr = this.type === EventType.put
+    this.attr = this.type === EventRecordType.put
       ? <keyof V>Object.keys(value).reduce((r, p) => p.length > 0 && p[0] !== '_' && p[p.length - 1] !== '_' ? p : r, '')
       : '';
     if (typeof this.attr !== 'string') throw new TypeError(`ClientChannel: EventRecord: Invalid event attr: ${this.key}`);
-    if (this.type === EventType.put && this.attr.length === 0) throw new TypeError(`ClientChannel: EventRecord: Invalid event attr with ${this.type}: ${this.attr}`);
-    if (this.type !== EventType.put && this.attr.length !== 0) throw new TypeError(`ClientChannel: EventRecord: Invalid event attr with ${this.type}: ${this.attr}`);
+    if (this.type === EventRecordType.put && this.attr.length === 0) throw new TypeError(`ClientChannel: EventRecord: Invalid event attr with ${this.type}: ${this.attr}`);
+    if (this.type !== EventRecordType.put && this.attr.length !== 0) throw new TypeError(`ClientChannel: EventRecord: Invalid event attr with ${this.type}: ${this.attr}`);
 
     switch (type) {
-      case EventType.put: {
-        this.value = value = clone<EventValue>(new EventValue(), <EventValue>{ [this.attr]: value[this.attr] });
+      case EventRecordType.put: {
+        this.value = value = clone<EventRecordValue>(new EventRecordValue(), <EventRecordValue>{ [this.attr]: value[this.attr] });
         void Object.freeze(this.value);
         void Object.freeze(this);
         return;
       }
-      case EventType.snapshot: {
-        this.value = value = clone<EventValue>(new EventValue(), value);
+      case EventRecordType.snapshot: {
+        this.value = value = clone<EventRecordValue>(new EventRecordValue(), value);
         void Object.freeze(this.value);
         void Object.freeze(this);
         return;
       }
-      case EventType.delete: {
-        this.value = value = new EventValue();
+      case EventRecordType.delete: {
+        this.value = value = new EventRecordValue();
         void Object.freeze(this.value);
         void Object.freeze(this);
         return;
@@ -58,12 +58,12 @@ abstract class EventRecord<K extends string, V extends EventValue> {
   }
   public readonly attr: keyof V | '';
 }
-export class UnsavedEventRecord<K extends string, V extends EventValue> extends EventRecord<K, V> {
+export class UnsavedEventRecord<K extends string, V extends EventRecordValue> extends EventRecord<K, V> {
   private EVENT_RECORD: V;
   constructor(
     key: K,
     value: Partial<V>,
-    type: EventType = EventType.put,
+    type: EventRecordType = EventRecordType.put,
     date: number = Date.now()
   ) {
     super(IdNumber(0), type, key, value, date);
@@ -72,13 +72,13 @@ export class UnsavedEventRecord<K extends string, V extends EventValue> extends
     if (this.id !== 0) throw new TypeError(`ClientChannel: UnsavedEventRecord: Invalid event id: ${this.id}`);
   }
 }
-export class SavedEventRecord<K extends string, V extends EventValue> extends EventRecord<K, V> {
+export class SavedEventRecord<K extends string, V extends EventRecordValue> extends EventRecord<K, V> {
   private EVENT_RECORD: V;
   constructor(
     id: IdNumber,
     key: K,
     value: Partial<V>,
-    type: EventType,
+    type: EventRecordType,
     date: number
   ) {
     super(id, type, key, value, date);
@@ -87,17 +87,17 @@ export class SavedEventRecord<K extends string, V extends EventValue> extends Ev
   }
 }
 
-export const EventType = {
-  put: <EventType.Put>'put',
-  delete: <EventType.Delete>'delete',
-  snapshot: <EventType.Snapshot>'snapshot'
+export const EventRecordType = {
+  put: <EventRecordType.Put>'put',
+  delete: <EventRecordType.Delete>'delete',
+  snapshot: <EventRecordType.Snapshot>'snapshot'
 };
-export type EventType = StoreChannelEvent.Type
-export namespace EventType {
-  export type Put = StoreChannelEvent.Type.Put;
-  export type Delete = StoreChannelEvent.Type.Delete;
-  export type Snapshot = StoreChannelEvent.Type.Snapshot;
+export type EventRecordType = StoreChannelEventType
+export namespace EventRecordType {
+  export type Put = StoreChannelEventType.Put;
+  export type Delete = StoreChannelEventType.Delete;
+  export type Snapshot = StoreChannelEventType.Snapshot;
 }
 
-export class EventValue {
+export class EventRecordValue {
 }