implab/implabjs-core Commit - r55:4eaaaa5c1cf3

ported string format traits to typescript

cin -

r55:4eaaaa5c1cf3 di-typescript

parent child

Context file:

r55:4eaaaa5c1cf3

Collapse all files

src/amd/ts/text/format-compile.ts created 644 +8 0

@@ -0,0 +1,8
	1	import * as module from "module";
	2	import { TraceSource } from "../log/TraceSource";
	3
	4	const logger = TraceSource.get(module.id);
	5
	6	logger.warn("The module is deprecated, use StringFormat.compile() method directly");
	7
	8	export { compile } from "./StringFormat";

src/amd/ts/text/format.ts created 644 +47 0

@@ -0,0 +1,47
	1	import { format as dojoFormatNumber } from "dojo/number";
	2	import { format as dojoFormatDate } from "dojo/date/locale";
	3	import { Formatter } from "./StringFormat";
	4
	5	import { isNumber } from "../safe";
	6
	7	interface NumberFormatOptions {
	8	round?: number;
	9	pattern?: string;
	10	}
	11
	12	function convertNumber(value: any, pattern: string) {
	13	if (isNumber(value)) {
	14	const nopt = {} as NumberFormatOptions;
	15	if (pattern.indexOf("!") === 0) {
	16	nopt.round = -1;
	17	pattern = pattern.substr(1);
	18	}
	19	nopt.pattern = pattern;
	20
	21	return dojoFormatNumber(value, nopt);
	22	}
	23	}
	24
	25	function convertDate(value: any, pattern: string) {
	26	if (value instanceof Date) {
	27	const m = pattern.match(/^(\w+)-(\w+)$/);
	28	if (m)
	29	return dojoFormatDate(value, {
	30	selector: m[2],
	31	formatLength: m[1]
	32	});
	33	else if (pattern === "iso")
	34	return value.toISOString();
	35	else
	36	return dojoFormatDate(value, {
	37	selector: "date",
	38	datePattern: pattern
	39	});
	40	}
	41	}
	42
	43	const _formatter = new Formatter([convertNumber, convertDate]);
	44
	45	export = function format(msg: string, ...args: any[]) {
	46	return _formatter.format.apply(msg, ...args);
	47	};

src/main/ts/text/StringFormat.ts created 644 +173 0

@@ -0,0 +1,173
	1	import { isPrimitive, isNull, each } from "../safe";
	2	import { MapOf } from "../interfaces";
	3
	4	type SubstFn = (name: string, format?: string) => string;
	5	type TemplateFn = (subst: SubstFn) => string;
	6	type ConvertFn = (value: any, format?: string) => string;
	7
	8	const map = {
	9	"\\{": "&curlopen;",
	10	"\\}": "&curlclose;",
	11	"&": "&",
	12	"\\:": "&colon;"
	13	};
	14
	15	const rev = {
	16	curlopen: "{",
	17	curlclose: "}",
	18	amp: "&",
	19	colon: ":"
	20	};
	21
	22	function espaceString(s: string) {
	23	if (!s)
	24	return s;
	25	return "'" + s.replace(/('\|\\)/g, "\\$1").replace("\n", "\\n") + "'";
	26	}
	27
	28	function encode(s: string) {
	29	if (!s)
	30	return s;
	31	return s.replace(/\\{\|\\}\|&\|\\:\|\n/g, m => map[m] \|\| m);
	32	}
	33
	34	function decode(s: string) {
	35	if (!s)
	36	return s;
	37	return s.replace(/&(\w+);/g, (m, $1) => rev[$1] \|\| m);
	38	}
	39
	40	function subst(s: string) {
	41	const i = s.indexOf(":");
	42	let name: string;
	43	let pattern: string;
	44	if (i >= 0) {
	45	name = s.substr(0, i);
	46	pattern = s.substr(i + 1);
	47	} else {
	48	name = s;
	49	}
	50
	51	if (pattern)
	52	return [
	53	espaceString(decode(name)),
	54	espaceString(decode(pattern))];
	55	else
	56	return [espaceString(decode(name))];
	57	}
	58
	59	function _compile(str: string) {
	60	if (!str)
	61	return () => void 0;
	62
	63	const chunks = encode(str).split("{");
	64	let chunk: string;
	65
	66	const code = ["var result=[];"];
	67
	68	for (let i = 0; i < chunks.length; i++) {
	69	chunk = chunks[i];
	70
	71	if (i === 0) {
	72	if (chunk)
	73	code.push("result.push(" + espaceString(decode(chunk)) +
	74	");");
	75	} else {
	76	const len = chunk.indexOf("}");
	77	if (len < 0)
	78	throw new Error("Unbalanced substitution #" + i);
	79
	80	code.push("result.push(subst(" +
	81	subst(chunk.substr(0, len)).join(",") + "));");
	82	if (chunk.length > len + 1)
	83	code.push("result.push(" +
	84	espaceString(decode(chunk.substr(len + 1))) + ");");
	85	}
	86	}
	87
	88	code.push("return result.join('');");
	89
	90	// the code for this function is generated from the template
	91	// tslint:disable-next-line:function-constructor
	92	return new Function("subst", code.join("\n")) as TemplateFn;
	93	}
	94
	95	const cache: MapOf<TemplateFn> = {};
	96
	97	export function compile(template: string) {
	98	let compiled = cache[template];
	99	if (!compiled) {
	100	compiled = _compile(template);
	101	cache[template] = compiled;
	102	}
	103	return compiled;
	104	}
	105
	106	function defaultConverter(value: any, pattern: string) {
	107	if (pattern && pattern.toLocaleLowerCase() === "json") {
	108	const seen = [];
	109	return JSON.stringify(value, (k, v) => {
	110	if (!isPrimitive(v)) {
	111	const id = seen.indexOf(v);
	112	if (id >= 0)
	113	return "@ref-" + id;
	114	else {
	115	seen.push(v);
	116	return v;
	117	}
	118	} else {
	119	return v;
	120	}
	121	}, 2);
	122	} else if (isNull(value)) {
	123	return "";
	124	} else if (value instanceof Date) {
	125	return value.toISOString();
	126	} else {
	127	return pattern ? value.toString(pattern) : value.toString();
	128	}
	129	}
	130
	131	export class Formatter {
	132	_converters: ConvertFn[];
	133
	134	constructor(converters?: ConvertFn[]) {
	135	this._converters = converters \|\| [];
	136	this._converters.push(defaultConverter);
	137	}
	138
	139	convert(value: any, pattern: string) {
	140	for (const c of this._converters) {
	141	const res = c(value, pattern);
	142	if (!isNull(res))
	143	return res;
	144	}
	145	return "";
	146	}
	147
	148	format(msg: string, ...args: any[]) {
	149	const template = compile(msg);
	150
	151	return template((name, pattern) => {
	152	const value = args[name];
	153	return !isNull(value) ? this.convert(value, pattern) : "";
	154	});
	155
	156	}
	157
	158	compile(msg: string) {
	159	const template = compile(msg);
	160	return (...args: any[]) => {
	161	return template((name, pattern) => {
	162	const value = args[name];
	163	return !isNull(value) ? this.convert(value, pattern) : "";
	164	});
	165	};
	166	}
	167	}
	168
	169	const _default = new Formatter();
	170
	171	export function format(msg: string, ...args: any[]) {
	172	return _default.format(msg, ...args);
	173	}

src/main/ts/interfaces.ts +4 0

             export type Constructor<T = {}> = new (...args: any[]) => T;
             export type Factory<T = {}> = (...args: any[]) => T;
+            export interface MapOf<T> {
+                [key: string]: T;
+            }
             export interface IDestroyable {
                 destroy();
             }
             export interface ICancellation {
                 throwIfRequested(): void;
                 isRequested(): boolean;
                 isSupported(): boolean;
                 register(cb: (e: any) => void): IDestroyable;
             }
             /**
              * Интерфейс поддерживающий асинхронную активацию
              */
             export interface IActivatable {
                 /**
                  * @returns Boolean indicates the current state
                  */
                 isActive(): boolean;
                 /**
                  * Starts the component activation
                  * @param ct cancellation token for this operation
                  */
                 activate(ct?: ICancellation): Promise<void>;
                 /**
                  * Starts the component deactivation
                  * @param ct cancellation token for this operation
                  */
                 deactivate(ct?: ICancellation): Promise<void>;
                 /**
                  * Sets the activation controller for this component
                  * @param controller The activation controller
                  *
                  * Activation controller checks whether this component
                  * can be activated and manages the active state of the
                  * component
                  */
                 setActivationController(controller: IActivationController);
                 /**
                  * Gets the current activation controller for this component
                  */
                 getActivationController(): IActivationController;
             }
             export interface IActivationController {
                 activating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 activated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivating(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivated(component: IActivatable, ct?: ICancellation): Promise<void>;
                 deactivate(ct?: ICancellation): Promise<void>;
                 activate(component: IActivatable, ct?: ICancellation): Promise<void>;
                 getActive(): IActivatable;
             }
             export interface IAsyncComponent {
                 getCompletion(): Promise<void>;
             }
             export interface ICancellable {
                 cancel(reason?: any): void;
             }
             export interface IObservable<T> {
                 on(next: (x: T) => void, error?: (e: any) => void, complete?: () => void): IDestroyable;
                 next(ct?: ICancellation): Promise<T>;
             }

src/main/ts/log/TraceSource.ts +2 -2

             import { Observable } from "../Observable";
             import { Registry } from "./Registry";
-            import { format } from "../text/FormatString";
+            import { format } from "../text/StringFormat";
             export const DebugLevel = 400;
             export const LogLevel = 300;
             export const WarnLevel = 200;
             export const ErrorLevel = 100;
             export const SilentLevel = 0;
             export interface TraceEvent {
                 readonly source: TraceSource;
                 readonly level: number;
                 readonly arg: any;
             }
             export class TraceSource {
                 readonly id: any;
                 level: number;
                 readonly events: Observable<TraceEvent>;
                 _notifyNext: (arg: TraceEvent) => void;
                 constructor(id: any) {
                     this.id = id || new Object();
                     this.events = new Observable(next => {
                         this._notifyNext = next;
                     });
                 }
                 protected emit(level: number, arg: any) {
-                    this._notifyNext({ source: this, level, arg});
+                    this._notifyNext({ source: this, level, arg });
                 }
                 isDebugEnabled() {
                     return this.level >= DebugLevel;
                 }
                 debug(msg: string, ...args: any[]) {
                     if (this.isEnabled(DebugLevel))
                         this.emit(DebugLevel, format(msg, args));
                 }
                 isLogEnabled() {
                     return this.level >= LogLevel;
                 }
                 log(msg: string, ...args: any[]) {
                     if (this.isEnabled(LogLevel))
                         this.emit(LogLevel, format(msg, args));
                 }
                 isWarnEnabled() {
                     return this.level >= WarnLevel;
                 }
                 warn(msg: string, ...args: any[]) {
                     if (this.isEnabled(WarnLevel))
                         this.emit(WarnLevel, format(msg, args));
                 }
                 /**
                  * returns true if errors will be recorded.
                  */
                 isErrorEnabled() {
                     return this.level >= ErrorLevel;
                 }
                 /**
                  * Traces a error.
                  *
                  * @param msg the message.
                  * @param args parameters which will be substituted in the message.
                  */
                 error(msg: string, ...args: any[]) {
                     if (this.isEnabled(ErrorLevel))
                         this.emit(ErrorLevel, format.apply(null, arguments));
                 }
                 /**
                  * Checks whether the specified level is enabled for this
                  * trace source.
                  *
                  * @param level the trace level which should be checked.
                  */
                 isEnabled(level: number) {
                     return (this.level >= level);
                 }
                 /**
                  * Traces a raw event, passing data as it is to the underlying listeners
                  *
                  * @param level the level of the event
                  * @param arg the data of the event, can be a simple string or any object.
                  */
                 traceEvent(level: number, arg: any) {
                     if (this.isEnabled(level))
                         this.emit(level, arg);
                 }
                 /**
                  * Register the specified handler to be called for every new and already
                  * created trace source.
                  *
                  * @param handler the handler which will be called for each trace source
                  */
                 static on(handler: (source: TraceSource) => void) {
                     return Registry.instance.on(handler);
                 }
                 /**
                  * Creates or returns already created trace source for the specified id.
                  *
                  * @param id the id for the trace source
                  */
                 static get(id: any) {
                     return Registry.instance.get(id);
                 }
             }

src/amd/js/text/format-compile.js removed 0 -101

NO CONTENT: file was removed

src/amd/js/text/format.js removed 0 -87

NO CONTENT: file was removed

src/amd/ts/format.ts removed 0 -40

NO CONTENT: file was removed

src/main/ts/text/FormatString.ts removed 0 -160

NO CONTENT: file was removed

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