@alterior/common 3.15.0 → 3.16.1

package/src/lazy-promise.ts

@@ -5,7 +5,7 @@
  */
 export class LazyPromise<T> extends Promise<T> {
     constructor(
-        private fulfiller : () => Promise<T>
+        private fulfiller: () => Promise<T>
     ) {
         super((resolve, reject) => {
             this._resolve = resolve;
@@ -14,8 +14,8 @@ export class LazyPromise<T> extends Promise<T> {
 
     }
 
-    private _resolve : (result : T) => void;
-    private _reject : (reason? : any) => void;
+    private _resolve!: (result: T) => void;
+    private _reject!: (reason?: any) => void;
 
     fulfill() {
         if (!this.realPromise) {
@@ -26,7 +26,7 @@ export class LazyPromise<T> extends Promise<T> {
         }
     }
 
-    private realPromise : Promise<void>;
+    private realPromise?: Promise<void>;
 
     then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2> {
         this.fulfill();

package/src/locks.ts

@@ -8,7 +8,7 @@ export class Lock {
     constructor() {
     }
 
-    private _ready : Promise<void>;
+    private _ready : Promise<void> | undefined;
     private static _namedLocks : Map<any, Lock>;
 
     static forToken<T extends Lock>(this : { new() : T }, token : any): T {
@@ -37,7 +37,7 @@ export class Lock {
         return lock;
     }
 
-    protected async executeCallback(cb) {
+    protected async executeCallback(cb: Function) {
         return await cb();
     }
 
@@ -76,7 +76,7 @@ export class ZoneLock extends Lock {
         super();
     }
 
-    protected async executeCallback(cb) {
+    protected async executeCallback<T>(cb: () => Promise<T> | T): Promise<T> {
         return await AsyncZone.run(cb);
     }
 }

package/src/object-entries-typed.ts

@@ -0,0 +1,7 @@
+export function objectEntriesTyped<T extends object>(object: T): [keyof T, T[keyof T]][] {
+    return Object.entries(object) as any;
+}
+
+export function objectKeysTyped<T extends object>(object: T): (keyof T)[] {
+    return Object.keys(object) as (keyof T)[];
+}

package/src/presentation.test.ts

@@ -13,14 +13,14 @@ suite(describe => {
             }
             
             function Nothing() {
-                return (target, ...args) => target;
+                return (target: any, ...args: any[]) => target;
             }
 
             @Nothing()
             class ApiMovie extends Presentation<Movie> {
-                @Expose() description : string;
-                @Expose() title : string;
-                @Expose() rating : number;
+                @Expose() description! : string;
+                @Expose() title! : string;
+                @Expose() rating! : number;
             }
 
             let props = ApiMovie.properties;
@@ -33,9 +33,9 @@ suite(describe => {
             expect(titleProp).to.exist
             expect(ratingProp).to.exist
             
-            expect(descProp.designType).to.equal(String);
-            expect(titleProp.designType).to.equal(String);
-            expect(ratingProp.designType).to.equal(Number);
+            expect(descProp!.designType).to.equal(String);
+            expect(titleProp!.designType).to.equal(String);
+            expect(ratingProp!.designType).to.equal(Number);
         });
 
         it('correctly handles subclassing', () => {
@@ -45,11 +45,11 @@ suite(describe => {
             }
             
             class ApiAbridgedMovie extends Presentation<Movie> {
-                @Expose() title : string;
+                @Expose() title! : string;
             }
             
             class ApiMovie extends ApiAbridgedMovie {
-                @Expose() description : string;
+                @Expose() description! : string;
             }
 
             let abridgedPresenter = new ApiAbridgedMovie({ title: 'Title', description: 'Description' });

package/src/presentation.ts

@@ -6,27 +6,27 @@ import { clone } from "./clone";
 export const EXPOSE_PROTOTYPE_STORAGE_KEY = '@alterior/common:Expose';
 
 export interface PresentedPropertyOptions {
-    useProperty? : string;
-    class? : Constructor<Presentation<any>>;
-    defaultValue? : any;
+    useProperty?: string;
+    class?: Constructor<Presentation<any>>;
+    defaultValue?: any;
 }
 
 export interface PresentedProperty {
-    propertyKey : string;
-    options : PresentedPropertyOptions;
-    designType? : any;
+    propertyKey: string;
+    options: PresentedPropertyOptions;
+    designType?: any;
 }
 
 export class PresentationSchema<T> {
-    constructor(readonly type : Constructor<Presentation<T>>) {
+    constructor(readonly type: Constructor<Presentation<T>>) {
         this.populate();
     }
 
     private populate() {
-        let exposureSets : PresentedProperty[][] = [];
+        let exposureSets: PresentedProperty[][] = [];
 
         let prototype = this.type.prototype;
-        let prototypes = [ ];
+        let prototypes = [];
 
         while (prototype) {
             prototypes.push(prototype);
@@ -38,13 +38,13 @@ export class PresentationSchema<T> {
 
         // Reverse the order so that the super-most properties appear first,
         // followed by the subproperties.
-        
+
         exposureSets = exposureSets.reverse();
 
         let exposures = exposureSets
             .reduce((pv, cv) => (pv.push(...cv), pv), [])
             .map(x => clone(x))
-        ;
+            ;
 
         for (let exposure of exposures) {
             let key = exposure.propertyKey;
@@ -54,7 +54,7 @@ export class PresentationSchema<T> {
             }
 
             let designType = null;
-            
+
             for (let prototype of prototypes) {
                 designType = Reflect.getMetadata('design:type', prototype, key);
                 if (designType)
@@ -68,7 +68,7 @@ export class PresentationSchema<T> {
         this.properties = exposures;
     }
 
-    properties : PresentedProperty[];
+    properties: PresentedProperty[] = [];
 }
 
 /**
@@ -83,7 +83,7 @@ export class PresentationSchema<T> {
  */
 export class Presentation<T> {
     constructor(
-        readonly instance : T
+        readonly instance: T
     ) {
     }
 
@@ -94,39 +94,39 @@ export class Presentation<T> {
      * @param this 
      * @param array 
      */
-    public static from<T extends Presentation<U>, U>(this : Constructor<T>, array : U[]) : T[] {
+    public static from<T extends Presentation<U>, U>(this: Constructor<T>, array: U[]): T[] {
         return array.map(x => new this(x));
     }
 
-    public static get properties() : PresentedProperty[] {
+    public static get properties(): PresentedProperty[] {
         return new PresentationSchema(this).properties;
     }
 
     public toJSON() {
         if (!this.instance)
             return null;
-        
+
         let properties = {};
-        let exposures : PresentedProperty[] = (this.constructor as any).properties;
+        let exposures: PresentedProperty[] = (this.constructor as any).properties;
 
         for (let exposure of exposures) {
             let key = exposure.propertyKey;
             let options = exposure.options;
-            
+
             let prototype = Object.getPrototypeOf(this);
 
             let propertyType = Reflect.getMetadata('design:type', this.constructor.prototype, key);
             let propertyDescriptor = Object.getOwnPropertyDescriptor(prototype, key);
-            let value = this[key];
+            let value = (this as any)[key];
 
             if (options.useProperty) {
-                value = this.instance[options.useProperty];
+                value = (this.instance as any)[options.useProperty];
             } else if (!propertyDescriptor || !propertyDescriptor.get) {
                 // Data property, fill from original object.
-                value = this.instance[key];
+                value = (this.instance as any)[key];
             }
 
-            let entityType : Constructor<Presentation<any>>;
+            let entityType: Constructor<Presentation<any>> | undefined;
 
             if (options.class) {
                 entityType = options.class;
@@ -141,7 +141,7 @@ export class Presentation<T> {
             if (value && value.toJSON)
                 value = value.toJSON();
 
-            properties[key] = value;
+            (properties as any)[key] = value;
         }
 
         return properties;
@@ -154,7 +154,7 @@ export class Presentation<T> {
  * 
  * @see Presentation<T>
  */
-export function Expose(options : PresentedPropertyOptions = {}) {
+export function Expose(options: PresentedPropertyOptions = {}) {
     return function (target: Object, propertyKey: string, descriptor?: PropertyDescriptor) {
 
         if (!target.hasOwnProperty(EXPOSE_PROTOTYPE_STORAGE_KEY)) {
@@ -164,11 +164,11 @@ export function Expose(options : PresentedPropertyOptions = {}) {
             });
         }
 
-        let exposures : PresentedProperty[] = target[EXPOSE_PROTOTYPE_STORAGE_KEY];
+        let exposures: PresentedProperty[] = (target as any)[EXPOSE_PROTOTYPE_STORAGE_KEY];
 
-		exposures.push(<PresentedProperty>{
-			propertyKey: propertyKey,
-			options
+        exposures.push(<PresentedProperty>{
+            propertyKey: propertyKey,
+            options
         });
-	};
+    };
 }

package/src/serializer.ts

@@ -1,3 +1,5 @@
+import { objectEntriesTyped } from "./object-entries-typed";
+
 /**
  * Prepare an object for serialization by removing any fields which are undefined
  * or functions and return the result. The operation is recursive across all subobjects.
@@ -5,20 +7,29 @@
  * 
  * @param data 
  */
-export function prepareForSerialization<T>(data : T): T {
+export function prepareForSerialization<T>(data : T): T;
+export function prepareForSerialization<T>(data : undefined): undefined;
+export function prepareForSerialization<T>(data : null): null;
+export function prepareForSerialization<T>(data : T | undefined): T | undefined;
+export function prepareForSerialization<T>(data : T | null): T | null;
+export function prepareForSerialization<T>(data : T | undefined | null): T | undefined | null;
+export function prepareForSerialization<T>(data : T | undefined | null): T | undefined | null {
     if (data === undefined || data === null)
-        return null;
+        return data;
 
-    if (data['toJSON'])
-        data = data['toJSON']();
+    if ((data as any).toJSON)
+        data = (data as any).toJSON();
     
+    if (data === undefined || data === null)
+        return data;
+
     if (typeof data !== 'object')
         return data;
     
-    return Object.entries(data)
+    return objectEntriesTyped(data)
             .filter(x => x[1] !== undefined)
             .filter(x => typeof x[1] !== 'function')
-            .map(x => [x[0], prepareForSerialization(x[1])])
+            .map(x => [x[0], prepareForSerialization(x[1])] as const)
             .reduce((o, [k,v]) => (o[k] = v, o), <T>{})
     ;
 }

package/src/timeout.ts

@@ -18,7 +18,7 @@ export function timeout(time : number = 0) : Promise<void> {
  * @param time 
  */
 export function interval(time : number) : Observable<void> {
-	let interval;
+	let interval: any;
 	return lazySubject({
 		start: subject => interval = setInterval(() => subject.next()),
 		stop: () => clearInterval(interval)

package/src/zones.ts

@@ -15,7 +15,7 @@ import { Observable, Subject } from 'rxjs';
  * and no further execution is possible.
  */
 export class AsyncZone {
-    public constructor(name : string, properties : any = {}) {
+    public constructor(name: string, properties: any = {}) {
         let self = this;
 
         this._outside = Zone.current;
@@ -26,7 +26,7 @@ export class AsyncZone {
             onInvoke(delegate, current, target, callback, applyThis, applyArgs, source) {
                 return self.innerInvoke(() => delegate.invoke(target, callback, applyThis, applyArgs, source));
             },
-            
+
             onInvokeTask(delegate: ZoneDelegate, current: Zone, target: Zone, task: Task, applyThis: any, applyArgs: any) {
                 return self.innerInvoke(() => delegate.invokeTask(target, task, applyThis, applyArgs));
             },
@@ -45,7 +45,7 @@ export class AsyncZone {
                     self._hasPendingMicrotasks = hasTaskState.microTask;
                 } else if (hasTaskState.change == 'macroTask') {
                     self._hasPendingMacrotasks = hasTaskState.macroTask;
-                    
+
                     if (hasTaskState.macroTask) {
                         if (!self._zonesWithPendingMacrotasks.includes(target))
                             self._zonesWithPendingMacrotasks.push(target);
@@ -56,7 +56,7 @@ export class AsyncZone {
 
                 self.checkStable();
             },
-            
+
             onHandleError(delegate, current, target, error) {
                 self.runOutside(() => self._onError.next(error));
                 return false;
@@ -64,23 +64,23 @@ export class AsyncZone {
         });
     }
 
-    private _zonesWithPendingMicrotasks : Zone[] = [];
-    private _zonesWithPendingMacrotasks : Zone[] = [];
+    private _zonesWithPendingMicrotasks: Zone[] = [];
+    private _zonesWithPendingMacrotasks: Zone[] = [];
 
-    private _outside : Zone;
-    private _nesting : number = 0;
-    private _hasPendingMicrotasks : boolean;
-    private _hasPendingMacrotasks : boolean;
-    private _zone : Zone;
-    private _onError : Subject<Error> = new Subject<Error>();
-    private _isStable : boolean;
-    private _onMicrotaskEmpty : Subject<void> = new Subject<void>();
-    private _onStable : Subject<void> = new Subject<void>();
+    private _outside: Zone;
+    private _nesting: number = 0;
+    private _hasPendingMicrotasks = false;
+    private _hasPendingMacrotasks = false;
+    private _zone: Zone;
+    private _onError: Subject<Error> = new Subject<Error>();
+    private _isStable = false;
+    private _onMicrotaskEmpty: Subject<void> = new Subject<void>();
+    private _onStable: Subject<void> = new Subject<void>();
 
-    public static run<T>(cb : () => (Promise<T> | T)): Promise<T> {
+    public static run<T>(cb: () => (Promise<T> | T)): Promise<T> {
         return new Promise<T>((resolve, reject) => {
             let zone = new AsyncZone('AsyncZone');
-            let value;
+            let value: T;
 
             zone.onStable.subscribe(() => resolve(value));
             zone.onError.subscribe(e => reject(e));
@@ -117,16 +117,16 @@ export class AsyncZone {
 
         if (this._zonesWithPendingMicrotasks.length > 0 || this._zonesWithPendingMacrotasks.length > 0)
             return;
-        
+
         try {
             this._nesting++;
-            this._onMicrotaskEmpty.next(null);
+            this._onMicrotaskEmpty.next();
         } finally {
             this._nesting--;
 
             if (!this._hasPendingMicrotasks) {
                 try {
-                    this.runOutside(() => this._onStable.next(null));
+                    this.runOutside(() => this._onStable.next());
                 } finally {
                     this._isStable = true;
                 }
@@ -134,15 +134,15 @@ export class AsyncZone {
         }
     }
 
-    public runOutside(runnable) {
+    public runOutside(runnable: Function) {
         this._outside.run(runnable);
     }
 
-    public invoke(callback : () => void) {
+    public invoke(callback: () => void) {
         this._zone.runGuarded(() => this.innerInvoke(callback));
     }
 
-    private innerInvoke(callback : () => void) {
+    private innerInvoke(callback: () => void) {
         this.onEnter();
         try {
             return callback();

package/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/base64.test.ts","./src/base64.ts","./src/cache.test.ts","./src/cache.ts","./src/check-native-async.ts","./src/clone.test.ts","./src/clone.ts","./src/coalesce.test.ts","./src/coalesce.ts","./src/colors.ts","./src/console.ts","./src/constructor.ts","./src/decorators.ts","./src/environment.ts","./src/errors.test.ts","./src/errors.ts","./src/get-param-names.ts","./src/index.ts","./src/is-constructor.test.ts","./src/is-constructor.ts","./src/lazy-promise.ts","./src/lazy-subject.ts","./src/locks.test.ts","./src/locks.ts","./src/padding.ts","./src/presentation.test.ts","./src/presentation.ts","./src/serializer.ts","./src/test.ts","./src/time.ts","./src/timeout.ts","./src/zones.ts"],"version":"5.9.3"}
+{"root":["./src/base64.test.ts","./src/base64.ts","./src/cache.test.ts","./src/cache.ts","./src/check-native-async.ts","./src/clone.test.ts","./src/clone.ts","./src/coalesce.test.ts","./src/coalesce.ts","./src/colors.ts","./src/console.ts","./src/constructor.ts","./src/decorators.ts","./src/environment.ts","./src/errors.test.ts","./src/errors.ts","./src/get-param-names.ts","./src/index.ts","./src/is-constructor.test.ts","./src/is-constructor.ts","./src/lazy-promise.ts","./src/lazy-subject.ts","./src/locks.test.ts","./src/locks.ts","./src/object-entries-typed.ts","./src/padding.ts","./src/presentation.test.ts","./src/presentation.ts","./src/serializer.ts","./src/test.ts","./src/time.ts","./src/timeout.ts","./src/zones.ts"],"version":"5.9.3"}