implab/implabjs-core Commit - r80:8ddb2322c855

Added ObservableValue...

cin -

r80:8ddb2322c855 default

parent child

Context file:

r80:8ddb2322c855

Collapse all files

src/main/ts/ObservableValue.ts created 644 +33 0

			@@ -0,0 +1,33
		1	import { Observable } from "./Observable";
		2	import { IDestroyable } from "./interfaces";
		3	import { argumentNotNull } from "./safe";
		4
		5	type Handler<T> = (x: T) => void;
		6
		7	export class ObservableValue<T> extends Observable<T> {
		8	private _value: T;
		9
		10	constructor(initial: T) {
		11	super();
		12	this._value = initial;
		13	}
		14
		15	getValue() {
		16	return this._value;
		17	}
		18
		19	setValue(value: T) {
		20	this._value = value;
		21	this._notifyNext(value);
		22	}
		23
		24	on(next: Handler<T>, error?: Handler<any>, complete?: () => void): IDestroyable {
		25	argumentNotNull(next, "next");
		26	try {
		27	next(this._value);
		28	} catch {
		29	// suppress error
		30	}
		31	return super.on(next, error, complete);
		32	}
		33	}

src/main/ts/safe.ts +35 -37

               *  own properties of the source are entirely copied to the destination.
               *
               */
-             export function mixin<T, S>(dest: T, source: S, template?: string[] | object): T & S {
+             export function mixin<T extends object, S extends object>(dest: T, source: S, template?: string[] | object): T & S {
                  argumentNotNull(dest, "to");
                  const _res = dest as T & S;
              export function delegate<T, K extends keyof T>(target: T, _method: (K | _AnyFn)) {
                  let method;
                  if (!(_method instanceof Function)) {
                      argumentNotNull(target, "target");
                      method = target[_method];
              }
              /**
-              * Для каждого элемента массива вызывает указанную функцию и сохраняет
-              * возвращенное значение в массиве результатов.
+              * Iterates over the specified array of items and calls the callback `cb`, if
+              * the result of the callback is a promise the next item from the array will be
+              * proceeded after the promise is resolved.
               *
-              * @remarks cb может выполняться асинхронно, при этом одновременно будет
-              *          только одна операция.
+              *
-              * @async
               */
-             export function pmap(items, cb) {
+             export function pmap<T, T2>(
+                 items: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
+                 cb: (item: T, i: number) => T2 | PromiseLike<T2>
+             ): T2[] | PromiseLike<T2[]> {
                  argumentNotNull(cb, "cb");
-                 if (isPromise(items))
+                 if (isPromise(items)) {
                      return items.then(data => pmap(data, cb));
+                 } else {
                  if (isNull(items) || !items.length)
-                     return items;
+                         return [];
                  let i = 0;
-                 const result = [];
+                     const result = new Array<T2>();
-                 function next() {
-                     let r;
-                     let ri;
-                     function chain(x) {
+                     const next = () => {
+                         while (i < items.length) {
+                             const r = cb(items[i], i);
+                             const ri = i;
+                             i++;
+                             if (isPromise(r)) {
+                                 return r.then(x => {
                          result[ri] = x;
                          return next();
+                     }
-                     while (i < items.length) {
-                         r = cb(items[i], i);
-                         ri = i;
-                         i++;
-                         if (isPromise(r)) {
-                             return r.then(chain);
+                                 });
                          } else {
                              result[ri] = r;
                          }
                      }
                      return result;
+                 }
+                     };
                  return next();
              }
+             }
-             export function pfor(items, cb) {
+             export function pfor<T>(
+                 items: ArrayLike<T> | PromiseLike<ArrayLike<T>>,
+                 cb: (item: T, i: number) => any
+             ): void | PromiseLike<void> {
                  argumentNotNull(cb, "cb");
-                 if (isPromise(items))
-                     return items.then(data => {
-                         return pmap(data, cb);
-                     });
+                 if (isPromise(items)) {
+                     return items.then(data => pfor(data, cb));
+                 } else {
                  if (isNull(items) || !items.length)
-                     return items;
+                         return;
                  let i = 0;
-                 function next() {
+                     const next = () => {
                      while (i < items.length) {
                          const r = cb(items[i], i);
                          i++;
                          if (isPromise(r))
                              return r.then(next);
                      }
+                 }
+                     };
                  return next();
              }
+             }
              export function first<T>(sequence: ArrayLike<T>): T;
              export function first<T>(sequence: PromiseLike<ArrayLike<T>>): PromiseLike<T>;
                          else
                              throw new Error("The sequence is empty");
                      } else if (cb) {
-                         cb(sequence[0]);
+                         return cb(sequence[0]);
                      } else {
                          return sequence[0];
                      }
                  } else {
                      if (err)
-                         err(new Error("The sequence is required"));
+                         return err(new Error("The sequence is required"));
                      else
                          throw new Error("The sequence is required");
                  }

src/main/ts/text/FormatCompiler.ts +4 0

                      this.pushSubst(fieldName, filedFormat);
                  }
                  pushSubst(fieldName: string, filedFormat: string) {
                      throw new Error("Method not implemented.");
                  }
                  readFieldFormat(scanner: FormatScanner): string {
                      throw new Error("Method not implemented.");
                  }
                  readColon(scanner: FormatScanner) {
                      if (!scanner.next())
                          this.dieUnexpectedEnd();
                      if (scanner.getTokenType() !== TokeType.Colon)
                          return false;
                  }
                  pushText(text: string) {

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages