Remove typings and replace missing methods with vscodes (#8217)

* remove typings and replace missing methods with vscodes

* fix strict-null-checks

* fix tests
This commit is contained in:
Anthony Dresser
2019-11-05 13:03:20 -08:00
committed by GitHub
parent 4645a8ba6b
commit 22a427f934
184 changed files with 634 additions and 43388 deletions

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -1,635 +0,0 @@
// Generated by typings
// Source: node_modules/typemoq/typemoq.node.d.ts
declare module 'typemoq' {
namespace TypeMoqIntern {
class Consts {
static IMATCH_ID_VALUE: string;
static IMATCH_ID_NAME: string;
static IMATCH_MATCHES_NAME: string;
}
}
namespace TypeMoqIntern {
class CurrentInterceptContext<T> {
call: proxy.IProxyCall<T>;
}
}
namespace TypeMoqIntern {
enum GlobalType {
Class = 0,
Function = 1,
Value = 2,
}
class GlobalMock<T> implements IGlobalMock<T> {
mock: Mock<T>;
private _name;
private _type;
container: Object;
constructor(mock: Mock<T>, _name: string, _type: GlobalType, container: Object);
static ofInstance<U>(instance: U, globalName?: string, container?: Object, behavior?: MockBehavior): GlobalMock<U>;
static ofType<U>(ctor: Ctor<U>, globalName?: string, container?: Object, behavior?: MockBehavior): GlobalMock<U>;
object: T;
name: string;
behavior: MockBehavior;
callBase: boolean;
type: GlobalType;
setup<TResult>(expression: IFunc2<T, TResult>): MethodCallReturn<T, TResult>;
verify<TResult>(expression: IFunc2<T, TResult>, times: Times): void;
verifyAll(): void;
reset(): void;
}
}
namespace TypeMoqIntern.Api {
interface ICallback<T, TResult> {
callback(action: IAction): IReturnsThrows<T, TResult>;
callback(action: IAction1<T>): IReturnsThrows<T, TResult>;
}
}
namespace TypeMoqIntern.Api {
interface IReturns<T, TResult> {
returns(valueFunction: IFuncN<any, TResult>): IReturnsResult<T>;
callBase(): IReturnsResult<T>;
}
interface IReturnsResult<T> extends IVerifies {
}
interface IReturnsThrows<T, TResult> extends IReturns<T, TResult>, IThrows {
}
}
namespace TypeMoqIntern.Api {
interface ISetup<T, TResult> extends ICallback<T, TResult>, IReturnsThrows<T, TResult>, IVerifies {
}
}
namespace TypeMoqIntern.Api {
interface IThrows {
throws<T extends error.Exception>(exception: T): IThrowsResult;
}
interface IThrowsResult extends IVerifies {
}
}
namespace TypeMoqIntern.Api {
interface IUsingResult {
with(action: IAction): void;
}
}
namespace TypeMoqIntern.Api {
interface IVerifies {
verifiable(times?: Times): void;
}
}
namespace TypeMoqIntern {
type Ctor<T> = {
new (): T;
prototype: Object;
};
type CtorWithArgs<T> = {
new (...ctorArgs: any[]): T;
prototype: Object;
};
}
namespace TypeMoqIntern {
type IAction = () => void;
type IAction1<T> = (x: T) => void;
type IActionN<T> = (...x: T[]) => void;
type IFunc1<TResult> = () => TResult;
type IFunc2<T, TResult> = (x: T) => TResult;
type IFuncN<T, TResult> = (...x: T[]) => TResult;
}
namespace TypeMoqIntern {
class PropertyRetriever {
static getOwnEnumerables(obj: any): {
name: string;
desc: PropertyDescriptor;
}[];
static getOwnNonenumerables(obj: any): {
name: string;
desc: PropertyDescriptor;
}[];
static getOwnEnumerablesAndNonenumerables(obj: any): {
name: string;
desc: PropertyDescriptor;
}[];
static getPrototypeEnumerables(obj: any): {
name: string;
desc: PropertyDescriptor;
}[];
static getPrototypeNonenumerables(obj: any): {
name: string;
desc: PropertyDescriptor;
}[];
static getPrototypeEnumerablesAndNonenumerables(obj: any): {
name: string;
desc: PropertyDescriptor;
}[];
static getOwnAndPrototypeEnumerables(obj: any): {
name: string;
desc: PropertyDescriptor;
}[];
static getOwnAndPrototypeNonenumerables(obj: any): {
name: string;
desc: PropertyDescriptor;
}[];
static getOwnAndPrototypeEnumerablesAndNonenumerables(obj: any): {
name: string;
desc: PropertyDescriptor;
}[];
private static _enumerable(obj, prop);
private static _notEnumerable(obj, prop);
private static _enumerableAndNotEnumerable(obj, prop);
private static _getPropertyNames(obj, iterateSelfBool, iteratePrototypeBool, includePropCb);
}
}
namespace TypeMoqIntern {
class Utils {
static getUUID(): string;
static functionName(fun: Object): string;
static conthunktor<U>(ctor: CtorWithArgs<U>, args: any[]): U;
}
}
namespace TypeMoqIntern.Error {
class Exception implements Error {
name: string;
message: string;
constructor(name: string, message?: string);
toString(): string;
}
}
namespace TypeMoqIntern.Error {
enum MockExceptionReason {
NoSetup,
MoreThanOneSetup,
InvalidSetup,
InvalidMatcher,
InvalidProxyArg,
UnknownGlobalType,
VerificationFailed,
}
class MockException extends Exception {
reason: MockExceptionReason;
ctx: any;
constructor(reason: MockExceptionReason, ctx: any, name?: string, message?: string);
toString(): string;
}
}
namespace TypeMoqIntern.Match {
interface IMatch {
___id: string;
___matches(object: Object): boolean;
}
}
namespace TypeMoqIntern.Match {
class MatchAnyObject<T> implements IMatch {
private _ctor;
___id: string;
constructor(_ctor: Ctor<T>);
___matches(object: Object): boolean;
}
class MatchAny implements IMatch {
___id: string;
___matches(object: Object): boolean;
}
class MatchAnyString implements IMatch {
___id: string;
___matches(object: Object): boolean;
}
class MatchAnyNumber implements IMatch {
___id: string;
___matches(object: Object): boolean;
}
}
namespace TypeMoqIntern.Match {
class MatchPred<T> implements IMatch {
private _pred;
___id: string;
constructor(_pred: IFunc2<T, boolean>);
___matches(object: Object): boolean;
}
}
namespace TypeMoqIntern.Match {
class MatchValue<T> implements IMatch {
private _value;
___id: string;
constructor(_value: T);
___matches(object: any): boolean;
}
}
namespace TypeMoqIntern.Proxy {
interface ICallContext {
args: IArguments;
property: IPropertyInfo;
returnValue: any;
invokeBase(): void;
}
}
namespace TypeMoqIntern.Proxy {
interface ICallInterceptor {
intercept(context: ICallContext): void;
}
}
namespace TypeMoqIntern.Proxy {
class MethodInvocation implements ICallContext {
private _property;
private _args;
returnValue: any;
constructor(_property: MethodInfo, _args?: IArguments);
args: IArguments;
property: PropertyInfo;
invokeBase(): void;
}
class ValueGetterInvocation implements ICallContext {
private _property;
returnValue: any;
constructor(_property: PropertyInfo, value: any);
args: IArguments;
property: PropertyInfo;
invokeBase(): void;
}
class ValueSetterInvocation implements ICallContext {
private _property;
private _args;
returnValue: any;
constructor(_property: PropertyInfo, _args: IArguments);
args: IArguments;
property: PropertyInfo;
invokeBase(): void;
}
class MethodGetterInvocation implements ICallContext {
private _property;
private _getter;
returnValue: any;
constructor(_property: PropertyInfo, _getter: () => any);
args: IArguments;
property: PropertyInfo;
invokeBase(): void;
}
class MethodSetterInvocation implements ICallContext {
private _property;
private _setter;
private _args;
returnValue: any;
constructor(_property: PropertyInfo, _setter: (v: any) => void, _args: IArguments);
args: IArguments;
property: PropertyInfo;
invokeBase(): void;
}
class MethodInfo implements IPropertyInfo {
obj: any;
name: string;
constructor(obj: any, name: string);
toFunc: Function;
}
class PropertyInfo implements IPropertyInfo {
obj: Object;
name: string;
constructor(obj: Object, name: string);
}
interface IPropertyInfo {
obj: Object;
name: string;
}
}
namespace TypeMoqIntern.Proxy {
interface IProxyCall<T> {
id: string;
setupExpression: IAction1<T>;
setupCall: proxy.ICallContext;
isVerifiable: boolean;
expectedCallCount: Times;
isInvoked: boolean;
callCount: number;
evaluatedSuccessfully(): void;
matches(call: proxy.ICallContext): boolean;
execute(call: proxy.ICallContext): void;
}
}
namespace TypeMoqIntern.Proxy {
interface IProxyFactory {
createProxy<T>(interceptor: ICallInterceptor, instance: T): T;
}
}
namespace TypeMoqIntern.Proxy {
class Proxy<T> {
constructor(interceptor: ICallInterceptor, instance: T);
static of<U>(instance: U, interceptor: ICallInterceptor): any;
private static check<U>(instance);
private check<U>(instance);
private static checkNotNull<U>(instance);
private static isPrimitiveObject(obj);
private defineMethodProxy(that, interceptor, instance, propName, propDesc?);
private static methodProxyValue<U>(interceptor, instance, propName);
private defineValuePropertyProxy(that, interceptor, instance, propName, propValue, propDesc?);
private defineGetSetPropertyProxy(that, interceptor, instance, propName, get?, set?, propDesc?);
private defineProperty(obj, name, desc);
}
}
namespace TypeMoqIntern.Proxy {
class ProxyFactory implements IProxyFactory {
createProxy<T>(interceptor: ICallInterceptor, instance: T): T;
}
}
import api = TypeMoqIntern.Api;
import error = TypeMoqIntern.Error;
import match = TypeMoqIntern.Match;
import proxy = TypeMoqIntern.Proxy;
namespace TypeMoqIntern {
class GlobalScope implements api.IUsingResult {
private _args;
constructor(_args: IGlobalMock<any>[]);
static using(...args: IGlobalMock<any>[]): api.IUsingResult;
with(action: IAction): void;
}
}
namespace TypeMoqIntern {
interface IGlobalMock<T> extends IMock<T> {
mock: Mock<T>;
type: GlobalType;
container: Object;
}
}
namespace TypeMoqIntern {
interface IMock<T> {
object: T;
name: string;
behavior: MockBehavior;
callBase: boolean;
setup<TResult>(expression: IFunc2<T, TResult>): MethodCallReturn<T, TResult>;
verify<TResult>(expression: IFunc2<T, TResult>, times: Times): void;
verifyAll(): void;
reset(): void;
}
}
namespace TypeMoqIntern {
enum InterceptionAction {
Continue = 0,
Stop = 1,
}
interface IInterceptStrategy<T> {
handleIntercept(invocation: proxy.ICallContext, ctx: InterceptorContext<T>, localCtx: CurrentInterceptContext<T>): InterceptionAction;
}
class InterceptorContext<T> {
behavior: MockBehavior;
mock: IMock<T>;
private _actualInvocations;
private _orderedCalls;
constructor(behavior: MockBehavior, mock: IMock<T>);
addInvocation(invocation: proxy.ICallContext): void;
actualInvocations(): proxy.ICallContext[];
clearInvocations(): void;
addOrderedCall(call: proxy.IProxyCall<T>): void;
removeOrderedCall(call: proxy.IProxyCall<T>): void;
orderedCalls(): proxy.IProxyCall<T>[];
}
}
namespace TypeMoqIntern {
class InterceptorExecute<T> implements Proxy.ICallInterceptor {
private _interceptorContext;
constructor(behavior: MockBehavior, mock: IMock<T>);
interceptorContext: InterceptorContext<T>;
intercept(invocation: proxy.ICallContext): void;
addCall(call: proxy.IProxyCall<T>): void;
verifyCall<T>(call: proxy.IProxyCall<T>, times: Times): void;
verify(): void;
private interceptionStrategies();
private throwVerifyCallException(call, times);
}
}
namespace TypeMoqIntern {
class InterceptorSetup<T> implements Proxy.ICallInterceptor {
private _interceptedCall;
interceptedCall: proxy.ICallContext;
intercept(invocation: proxy.ICallContext): void;
}
}
namespace TypeMoqIntern {
class AddActualInvocation<T> implements IInterceptStrategy<T> {
handleIntercept(invocation: proxy.ICallContext, ctx: InterceptorContext<T>, localCtx: CurrentInterceptContext<T>): InterceptionAction;
}
class ExtractProxyCall<T> implements IInterceptStrategy<T> {
handleIntercept(invocation: proxy.ICallContext, ctx: InterceptorContext<T>, localCtx: CurrentInterceptContext<T>): InterceptionAction;
}
class ExecuteCall<T> implements IInterceptStrategy<T> {
private _ctx;
handleIntercept(invocation: proxy.ICallContext, ctx: InterceptorContext<T>, localCtx: CurrentInterceptContext<T>): InterceptionAction;
}
class InvokeBase<T> implements IInterceptStrategy<T> {
handleIntercept(invocation: proxy.ICallContext, ctx: InterceptorContext<T>, localCtx: CurrentInterceptContext<T>): InterceptionAction;
}
class HandleMockRecursion<T> implements IInterceptStrategy<T> {
handleIntercept(invocation: proxy.ICallContext, ctx: InterceptorContext<T>, localCtx: CurrentInterceptContext<T>): InterceptionAction;
}
}
namespace TypeMoqIntern {
class It {
static isValue<T>(x: T): T;
static isAnyObject<T>(x: Ctor<T>): T;
static isAny(): any;
static isAnyString(): string;
static isAnyNumber(): number;
static is<T>(predicate: IFunc2<T, boolean>): T;
}
}
namespace TypeMoqIntern {
class MethodCall<T, TResult> implements proxy.IProxyCall<T>, api.IVerifies {
mock: Mock<T>;
private _setupExpression;
protected _id: string;
protected _setupCall: proxy.ICallContext;
protected _setupCallback: IAction;
protected _isVerifiable: boolean;
protected _expectedCallCount: Times;
protected _isInvoked: boolean;
protected _callCount: number;
protected _thrownException: error.Exception;
protected _evaluatedSuccessfully: boolean;
constructor(mock: Mock<T>, _setupExpression: IFunc2<T, TResult>);
private generateId();
private transformToMatchers(args);
id: string;
setupExpression: IAction1<T>;
setupCall: proxy.ICallContext;
isVerifiable: boolean;
expectedCallCount: Times;
isInvoked: boolean;
callCount: number;
evaluatedSuccessfully(): void;
matches(call: proxy.ICallContext): boolean;
execute(call: proxy.ICallContext): void;
verifiable(times?: Times): void;
}
}
namespace TypeMoqIntern {
class MethodCallReturn<T, TResult> extends MethodCall<T, TResult> implements api.ISetup<T, TResult>, api.IReturnsResult<T> {
protected _returnValueFunc: IFuncN<any, TResult>;
hasReturnValue: boolean;
protected _callBase: boolean;
constructor(mock: Mock<T>, setupExpression: IFunc2<T, TResult>);
execute(call: proxy.ICallContext): void;
callback(action: IActionN<any>): api.IReturnsThrows<T, TResult>;
throws(exception: Error): api.IThrowsResult;
returns(valueFunc: IFuncN<any, TResult>): api.IReturnsResult<T>;
callBase(): api.IReturnsResult<T>;
}
}
namespace TypeMoqIntern {
enum MockBehavior {
Loose = 0,
Strict = 1,
}
class Mock<T> implements IMock<T> {
instance: T;
private _behavior;
static proxyFactory: proxy.IProxyFactory;
private _id;
private _name;
private _interceptor;
private _proxy;
private _callBase;
constructor(instance: T, _behavior?: MockBehavior);
private init();
static ofInstance<U>(instance: U, behavior?: MockBehavior): Mock<U>;
static ofType<U>(ctor: CtorWithArgs<U>, behavior?: MockBehavior, ...ctorArgs: any[]): Mock<U>;
static ofType2<U>(ctor: CtorWithArgs<U>, ctorArgs: any[], behavior?: MockBehavior): Mock<U>;
object: T;
name: string;
behavior: MockBehavior;
callBase: boolean;
private generateId();
private getNameOf(instance);
setup<TResult>(expression: IFunc2<T, TResult>): MethodCallReturn<T, TResult>;
verify<TResult>(expression: IFunc2<T, TResult>, times: Times): void;
verifyAll(): void;
reset(): void;
}
}
namespace TypeMoqIntern {
class Times {
private _condition;
private _from;
private _to;
private static NO_MATCHING_CALLS_EXACTLY_N_TIMES;
private static NO_MATCHING_CALLS_AT_LEAST_ONCE;
private static NO_MATCHING_CALLS_AT_MOST_ONCE;
private _lastCallCount;
private _failMessage;
constructor(_condition: IFunc2<number, boolean>, _from: number, _to: number, failMessage: string);
failMessage: string;
verify(callCount: number): boolean;
static exactly(n: number): Times;
static never(): Times;
static once(): Times;
static atLeastOnce(): Times;
static atMostOnce(): Times;
}
}
interface ITypeMoq {
Mock: typeof TypeMoqIntern.Mock;
MockBehavior: typeof TypeMoqIntern.MockBehavior;
It: typeof TypeMoqIntern.It;
Times: typeof TypeMoqIntern.Times;
GlobalMock: typeof TypeMoqIntern.GlobalMock;
GlobalScope: typeof TypeMoqIntern.GlobalScope;
MockException: typeof TypeMoqIntern.Error.MockException;
}
module TypeMoq {
export import Mock = TypeMoqIntern.Mock;
export import MockBehavior = TypeMoqIntern.MockBehavior;
export import It = TypeMoqIntern.It;
export import Times = TypeMoqIntern.Times;
export import GlobalMock = TypeMoqIntern.GlobalMock;
export import GlobalScope = TypeMoqIntern.GlobalScope;
export import MockException = TypeMoqIntern.Error.MockException;
}
let typemoq: ITypeMoq;
//# sourceMappingURL=output.d.ts.map
export = TypeMoq;
}

File diff suppressed because it is too large Load Diff

View File

@@ -1,343 +0,0 @@
// Generated by typings
// Source: node_modules/zone.js/dist/zone.js.d.ts
interface Zone {
/**
*
* @returns {Zone} The parent Zone.
*/
parent: Zone;
/**
* @returns {string} The Zone name (useful for debugging)
*/
name: string;
/**
* Returns a value associated with the `key`.
*
* If the current zone does not have a key, the request is delegated to the parent zone. Use
* [ZoneSpec.properties] to configure the set of properties associated with the current zone.
*
* @param key The key to retrieve.
* @returns {any} The value for the key, or `undefined` if not found.
*/
get(key: string): any;
/**
* Returns a Zone which defines a `key`.
*
* Recursively search the parent Zone until a Zone which has a property `key` is found.
*
* @param key The key to use for identification of the returned zone.
* @returns {Zone} The Zone which defines the `key`, `null` if not found.
*/
getZoneWith(key: string): Zone;
/**
* Used to create a child zone.
*
* @param zoneSpec A set of rules which the child zone should follow.
* @returns {Zone} A new child zone.
*/
fork(zoneSpec: ZoneSpec): Zone;
/**
* Wraps a callback function in a new function which will properly restore the current zone upon
* invocation.
*
* The wrapped function will properly forward `this` as well as `arguments` to the `callback`.
*
* Before the function is wrapped the zone can intercept the `callback` by declaring
* [ZoneSpec.onIntercept].
*
* @param callback the function which will be wrapped in the zone.
* @param source A unique debug location of the API being wrapped.
* @returns {function(): *} A function which will invoke the `callback` through [Zone.runGuarded].
*/
wrap(callback: Function, source: string): Function;
/**
* Invokes a function in a given zone.
*
* The invocation of `callback` can be intercepted be declaring [ZoneSpec.onInvoke].
*
* @param callback The function to invoke.
* @param applyThis
* @param applyArgs
* @param source A unique debug location of the API being invoked.
* @returns {any} Value from the `callback` function.
*/
run<T>(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): T;
/**
* Invokes a function in a given zone and catches any exceptions.
*
* Any exceptions thrown will be forwarded to [Zone.HandleError].
*
* The invocation of `callback` can be intercepted be declaring [ZoneSpec.onInvoke]. The
* handling of exceptions can intercepted by declaring [ZoneSpec.handleError].
*
* @param callback The function to invoke.
* @param applyThis
* @param applyArgs
* @param source A unique debug location of the API being invoked.
* @returns {any} Value from the `callback` function.
*/
runGuarded<T>(callback: Function, applyThis?: any, applyArgs?: any[], source?: string): T;
/**
* Execute the Task by restoring the [Zone.currentTask] in the Task's zone.
*
* @param callback
* @param applyThis
* @param applyArgs
* @returns {*}
*/
runTask(task: Task, applyThis?: any, applyArgs?: any): any;
scheduleMicroTask(source: string, callback: Function, data?: TaskData, customSchedule?: (task: Task) => void): MicroTask;
scheduleMacroTask(source: string, callback: Function, data: TaskData, customSchedule: (task: Task) => void, customCancel: (task: Task) => void): MacroTask;
scheduleEventTask(source: string, callback: Function, data: TaskData, customSchedule: (task: Task) => void, customCancel: (task: Task) => void): EventTask;
/**
* Allows the zone to intercept canceling of scheduled Task.
*
* The interception is configured using [ZoneSpec.onCancelTask]. The default canceler invokes
* the [Task.cancelFn].
*
* @param task
* @returns {any}
*/
cancelTask(task: Task): any;
}
interface ZoneType {
/**
* @returns {Zone} Returns the current [Zone]. Returns the current zone. The only way to change
* the current zone is by invoking a run() method, which will update the current zone for the
* duration of the run method callback.
*/
current: Zone;
/**
* @returns {Task} The task associated with the current execution.
*/
currentTask: Task;
/**
* Verify that Zone has been correctly patched. Specifically that Promise is zone aware.
*/
assertZonePatched(): any;
}
/**
* Provides a way to configure the interception of zone events.
*
* Only the `name` property is required (all other are optional).
*/
interface ZoneSpec {
/**
* The name of the zone. Usefull when debugging Zones.
*/
name: string;
/**
* A set of properties to be associated with Zone. Use [Zone.get] to retrive them.
*/
properties?: {
[key: string]: any;
};
/**
* Allows the interception of zone forking.
*
* When the zone is being forked, the request is forwarded to this method for interception.
*
* @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
* @param currentZone The current [Zone] where the current interceptor has beed declared.
* @param targetZone The [Zone] which originally received the request.
* @param zoneSpec The argument passed into the `fork` method.
*/
onFork?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, zoneSpec: ZoneSpec) => Zone;
/**
* Allows interception of the wrapping of the callback.
*
* @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
* @param currentZone The current [Zone] where the current interceptor has beed declared.
* @param targetZone The [Zone] which originally received the request.
* @param delegate The argument passed into the `warp` method.
* @param source The argument passed into the `warp` method.
*/
onIntercept?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function, source: string) => Function;
/**
* Allows interception of the callback invocation.
*
* @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
* @param currentZone The current [Zone] where the current interceptor has beed declared.
* @param targetZone The [Zone] which originally received the request.
* @param delegate The argument passed into the `run` method.
* @param applyThis The argument passed into the `run` method.
* @param applyArgs The argument passed into the `run` method.
* @param source The argument passed into the `run` method.
*/
onInvoke?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, delegate: Function, applyThis: any, applyArgs: any[], source: string) => any;
/**
* Allows interception of the error handling.
*
* @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
* @param currentZone The current [Zone] where the current interceptor has beed declared.
* @param targetZone The [Zone] which originally received the request.
* @param error The argument passed into the `handleError` method.
*/
onHandleError?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, error: any) => boolean;
/**
* Allows interception of task scheduling.
*
* @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
* @param currentZone The current [Zone] where the current interceptor has beed declared.
* @param targetZone The [Zone] which originally received the request.
* @param task The argument passed into the `scheduleTask` method.
*/
onScheduleTask?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task) => Task;
onInvokeTask?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task, applyThis: any, applyArgs: any) => any;
/**
* Allows interception of task cancelation.
*
* @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
* @param currentZone The current [Zone] where the current interceptor has beed declared.
* @param targetZone The [Zone] which originally received the request.
* @param task The argument passed into the `cancelTask` method.
*/
onCancelTask?: (parentZoneDelegate: ZoneDelegate, currentZone: Zone, targetZone: Zone, task: Task) => any;
/**
* Notifies of changes to the task queue empty status.
*
* @param parentZoneDelegate Delegate which performs the parent [ZoneSpec] operation.
* @param currentZone The current [Zone] where the current interceptor has beed declared.
* @param targetZone The [Zone] which originally received the request.
* @param isEmpty
*/
onHasTask?: (delegate: ZoneDelegate, current: Zone, target: Zone, hasTaskState: HasTaskState) => void;
}
/**
* A delegate when intercepting zone operations.
*
* A ZoneDelegate is needed because a child zone can't simply invoke a method on a parent zone. For
* example a child zone wrap can't just call parent zone wrap. Doing so would create a callback
* which is bound to the parent zone. What we are interested is intercepting the callback before it
* is bound to any zone. Furthermore, we also need to pass the targetZone (zone which received the
* original request) to the delegate.
*
* The ZoneDelegate methods mirror those of Zone with an addition of extra targetZone argument in
* the method signature. (The original Zone which received the request.) Some methods are renamed
* to prevent confusion, because they have slightly different semantics and arguments.
*
* - `wrap` => `intercept`: The `wrap` method delegates to `intercept`. The `wrap` method returns
* a callback which will run in a given zone, where as intercept allows wrapping the callback
* so that additional code can be run before and after, but does not associated the callback
* with the zone.
* - `run` => `invoke`: The `run` method delegates to `invoke` to perform the actual execution of
* the callback. The `run` method switches to new zone; saves and restores the `Zone.current`;
* and optionally performs error handling. The invoke is not responsible for error handling,
* or zone management.
*
* Not every method is usually overwritten in the child zone, for this reason the ZoneDelegate
* stores the closest zone which overwrites this behavior along with the closest ZoneSpec.
*
* NOTE: We have tried to make this API analogous to Event bubbling with target and current
* properties.
*
* Note: The ZoneDelegate treats ZoneSpec as class. This allows the ZoneSpec to use its `this` to
* store internal state.
*/
interface ZoneDelegate {
zone: Zone;
fork(targetZone: Zone, zoneSpec: ZoneSpec): Zone;
intercept(targetZone: Zone, callback: Function, source: string): Function;
invoke(targetZone: Zone, callback: Function, applyThis: any, applyArgs: any[], source: string): any;
handleError(targetZone: Zone, error: any): boolean;
scheduleTask(targetZone: Zone, task: Task): Task;
invokeTask(targetZone: Zone, task: Task, applyThis: any, applyArgs: any): any;
cancelTask(targetZone: Zone, task: Task): any;
hasTask(targetZone: Zone, isEmpty: HasTaskState): void;
}
declare type HasTaskState = {
microTask: boolean;
macroTask: boolean;
eventTask: boolean;
change: TaskType;
};
/**
* Task type: `microTask`, `macroTask`, `eventTask`.
*/
declare type TaskType = string;
/**
*/
interface TaskData {
/**
* A periodic [MacroTask] is such which get automatically rescheduled after it is executed.
*/
isPeriodic?: boolean;
/**
* Delay in milliseconds when the Task will run.
*/
delay?: number;
/**
* identifier returned by the native setTimeout.
*/
handleId?: number;
}
/**
* Represents work which is executed with a clean stack.
*
* Tasks are used in Zones to mark work which is performed on clean stack frame. There are three
* kinds of task. [MicroTask], [MacroTask], and [EventTask].
*
* A JS VM can be modeled as a [MicroTask] queue, [MacroTask] queue, and [EventTask] set.
*
* - [MicroTask] queue represents a set of tasks which are executing right after the current stack
* frame becomes clean and before a VM yield. All [MicroTask]s execute in order of insertion
* before VM yield and the next [MacroTask] is executed.
* - [MacroTask] queue represents a set of tasks which are executed one at a time after each VM
* yield. The queue is order by time, and insertions can happen in any location.
* - [EventTask] is a set of tasks which can at any time be inserted to the end of the [MacroTask]
* queue. This happens when the event fires.
*
*/
interface Task {
/**
* Task type: `microTask`, `macroTask`, `eventTask`.
*/
type: TaskType;
/**
* Debug string representing the API which requested the scheduling of the task.
*/
source: string;
/**
* The Function to be used by the VM on entering the [Task]. This function will delegate to
* [Zone.runTask] and delegate to `callback`.
*/
invoke: Function;
/**
* Function which needs to be executed by the Task after the [Zone.currentTask] has been set to
* the current task.
*/
callback: Function;
/**
* Task specific options associated with the current task. This is passed to the `scheduleFn`.
*/
data: TaskData;
/**
* Represents the default work which needs to be done to schedule the Task by the VM.
*
* A zone may chose to intercept this function and perform its own scheduling.
*/
scheduleFn: (task: Task) => void;
/**
* Represents the default work which needs to be done to un-schedule the Task from the VM. Not all
* Tasks are cancelable, and therefore this method is optional.
*
* A zone may chose to intercept this function and perform its own scheduling.
*/
cancelFn: (task: Task) => void;
/**
* @type {Zone} The zone which will be used to invoke the `callback`. The Zone is captured
* at the time of Task creation.
*/
zone: Zone;
/**
* Number of times the task has been executed, or -1 if canceled.
*/
runCount: number;
}
interface MicroTask extends Task {
}
interface MacroTask extends Task {
}
interface EventTask extends Task {
}
declare const Zone: ZoneType;

View File

@@ -1,21 +0,0 @@
/// <reference path="globals/core-js/index.d.ts" />
/// <reference path="globals/jqueryui/index.d.ts" />
/// <reference path="globals/slickgrid/index.d.ts" />
/// <reference path="globals/underscore/index.d.ts" />
/// <reference path="globals/zone.js/index.d.ts" />
/// <reference path="modules/@angular/common/index.d.ts" />
/// <reference path="modules/@angular/compiler/index.d.ts" />
/// <reference path="modules/@angular/core/index.d.ts" />
/// <reference path="modules/@angular/forms/index.d.ts" />
/// <reference path="modules/@angular/platform-browser-dynamic/index.d.ts" />
/// <reference path="modules/@angular/platform-browser/index.d.ts" />
/// <reference path="modules/@angular/router/index.d.ts" />
/// <reference path="modules/@types/htmlparser2/index.d.ts" />
/// <reference path="modules/@types/sanitize-html/index.d.ts" />
/// <reference path="modules/angular2-grid/index.d.ts" />
/// <reference path="modules/angular2-slickgrid/index.d.ts" />
/// <reference path="modules/ansi_up/index.d.ts" />
/// <reference path="modules/html-query-plan/index.d.ts" />
/// <reference path="modules/ng2-charts/index.d.ts" />
/// <reference path="modules/rxjs/index.d.ts" />
/// <reference path="modules/@types/plotly.js-dist/index.d.ts" />

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -1,113 +0,0 @@
// Generated by typings
// Source: node_modules/@angular/platform-browser-dynamic/src/platform_providers.d.ts
declare module '~@angular/platform-browser-dynamic/src/platform_providers' {
import { Provider } from '@angular/core';
export const INTERNAL_BROWSER_DYNAMIC_PLATFORM_PROVIDERS: Provider[];
}
declare module '@angular/platform-browser-dynamic/src/platform_providers' {
export * from '~@angular/platform-browser-dynamic/src/platform_providers';
}
// Generated by typings
// Source: node_modules/@angular/platform-browser-dynamic/src/resource_loader/resource_loader_impl.d.ts
declare module '~@angular/platform-browser-dynamic/src/resource_loader/resource_loader_impl' {
/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { ResourceLoader } from '@angular/compiler';
export class ResourceLoaderImpl extends ResourceLoader {
get(url: string): Promise<string>;
}
}
declare module '@angular/platform-browser-dynamic/src/resource_loader/resource_loader_impl' {
export * from '~@angular/platform-browser-dynamic/src/resource_loader/resource_loader_impl';
}
// Generated by typings
// Source: node_modules/@angular/platform-browser-dynamic/src/private_export.d.ts
declare module '~@angular/platform-browser-dynamic/src/private_export' {
/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
export { INTERNAL_BROWSER_DYNAMIC_PLATFORM_PROVIDERS as ɵINTERNAL_BROWSER_DYNAMIC_PLATFORM_PROVIDERS } from '~@angular/platform-browser-dynamic/src/platform_providers';
export { ResourceLoaderImpl as ɵResourceLoaderImpl } from '~@angular/platform-browser-dynamic/src/resource_loader/resource_loader_impl';
}
declare module '@angular/platform-browser-dynamic/src/private_export' {
export * from '~@angular/platform-browser-dynamic/src/private_export';
}
// Generated by typings
// Source: node_modules/@angular/platform-browser-dynamic/src/version.d.ts
declare module '~@angular/platform-browser-dynamic/src/version' {
/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
/**
* @module
* @description
* Entry point for all public APIs of the common package.
*/
import { Version } from '@angular/core';
/**
* @stable
*/
export const VERSION: Version;
}
declare module '@angular/platform-browser-dynamic/src/version' {
export * from '~@angular/platform-browser-dynamic/src/version';
}
// Generated by typings
// Source: node_modules/@angular/platform-browser-dynamic/src/platform-browser-dynamic.d.ts
declare module '~@angular/platform-browser-dynamic/src/platform-browser-dynamic' {
import { PlatformRef, Provider } from '@angular/core';
export * from '~@angular/platform-browser-dynamic/src/private_export';
export { VERSION } from '~@angular/platform-browser-dynamic/src/version';
/**
* @experimental
*/
export const RESOURCE_CACHE_PROVIDER: Provider[];
/**
* @stable
*/
export const platformBrowserDynamic: (extraProviders?: Provider[] | undefined) => PlatformRef;
}
declare module '@angular/platform-browser-dynamic/src/platform-browser-dynamic' {
export * from '~@angular/platform-browser-dynamic/src/platform-browser-dynamic';
}
// Generated by typings
// Source: node_modules/@angular/platform-browser-dynamic/platform-browser-dynamic.d.ts
declare module '~@angular/platform-browser-dynamic/platform-browser-dynamic' {
/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
/**
* @module
* @description
* Entry point for all public APIs of the platform-browser-dynamic package.
*/
export * from '~@angular/platform-browser-dynamic/src/platform-browser-dynamic';
}
declare module '@angular/platform-browser-dynamic/platform-browser-dynamic' {
export * from '~@angular/platform-browser-dynamic/platform-browser-dynamic';
}
declare module '@angular/platform-browser-dynamic' {
export * from '~@angular/platform-browser-dynamic/platform-browser-dynamic';
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@@ -1,106 +0,0 @@
// Generated by typings
// Source: node_modules/@types/htmlparser2/index.d.ts
declare module 'htmlparser2' {
// Type definitions for htmlparser2 v3.7.x
// Project: https://github.com/fb55/htmlparser2/
// Definitions by: James Roland Cabresos <https://github.com/staticfunction>
// Linus Unnebäck <https://github.com/LinusU>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
///<reference types="node"/>
import { Writable } from 'stream'
export interface Handler {
onopentag?: (name: string, attribs: { [type: string]: string }) => void;
onopentagname?: (name: string) => void;
onattribute?: (name: string, value: string) => void;
ontext?: (text: string) => void;
onclosetag?: (text: string) => void;
onprocessinginstruction?: (name: string, data: string) => void;
oncomment?: (data: string) => void;
oncommentend?: () => void;
oncdatastart?: () => void;
oncdataend?: () => void;
onerror?: (error: Error) => void;
onreset?: () => void;
onend?: () => void;
}
export interface Options {
/***
* Indicates whether special tags (<script> and <style>) should get special treatment
* and if "empty" tags (eg. <br>) can have children. If false, the content of special tags
* will be text only. For feeds and other XML content (documents that don't consist of HTML),
* set this to true. Default: false.
*/
xmlMode?: boolean;
/***
* If set to true, entities within the document will be decoded. Defaults to false.
*/
decodeEntities?: boolean;
/***
* If set to true, all tags will be lowercased. If xmlMode is disabled, this defaults to true.
*/
lowerCaseTags?: boolean;
/***
* If set to true, all attribute names will be lowercased. This has noticeable impact on speed, so it defaults to false.
*/
lowerCaseAttributeNames?: boolean;
/***
* If set to true, CDATA sections will be recognized as text even if the xmlMode option is not enabled.
* NOTE: If xmlMode is set to true then CDATA sections will always be recognized as text.
*/
recognizeCDATA?: boolean;
/***
* If set to true, self-closing tags will trigger the onclosetag event even if xmlMode is not set to true.
* NOTE: If xmlMode is set to true then self-closing tags will always be recognized.
*/
recognizeSelfClosing?: boolean;
}
export class WritableStream extends Writable {
constructor(handler: Handler, options?: Options);
}
export class Parser {
constructor(handler: Handler, options?: Options);
/***
* Parses a chunk of data and calls the corresponding callbacks.
* @param input
*/
write(input: string): void;
/***
* alias for backwards compat
*/
parseChunk(input: string): void;
/***
* Parses the end of the buffer and clears the stack, calls onend.
*/
end(): void;
/***
* alias for backwards compat
*/
done(): void;
/***
* Resets the parser, parses the data & calls end.
* @param input
*/
parseComplete(input: string): void;
/***
* Resets buffer & stack, calls onreset.
*/
reset(): void;
}
}

File diff suppressed because it is too large Load Diff

View File

@@ -1,70 +0,0 @@
// Generated by typings
// Source: node_modules/@types/sanitize-html/index.d.ts
declare module 'sanitize-html' {
// Type definitions for sanitize-html 1.18.2
// Project: https://github.com/punkave/sanitize-html
// Definitions by: Rogier Schouten <https://github.com/rogierschouten>
// Afshin Darian <https://github.com/afshin>
// BehindTheMath <https://github.com/BehindTheMath>
// Rinze de Laat <https://github.com/biermeester>
// Will Gibson <https://github.com/WillGibson>
// A penguin <https://github.com/sirMerr>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
import {Options} from 'htmlparser2';
export = sanitize;
function sanitize(dirty: string, options?: sanitize.IOptions): string;
namespace sanitize {
type Attributes = { [attr: string]: string };
type Tag = { tagName: string; attribs: Attributes; text?: string; };
type Transformer = (tagName: string, attribs: Attributes) => Tag;
interface IDefaults {
allowedAttributes: { [index: string]: string[] };
allowedSchemes: string[];
allowedSchemesByTag: { [index: string]: string[] };
allowedTags: string[];
selfClosing: string[];
}
interface IFrame {
tag: string;
attribs: { [index: string]: string };
text: string;
tagPosition: number;
}
interface IOptions {
allowedAttributes?: { [index: string]: string[] } | boolean;
allowedStyles?: { [index: string]: { [index: string]: RegExp[] } };
allowedClasses?: { [index: string]: string[] } | boolean;
allowedIframeHostnames?: string[];
allowedSchemes?: string[] | boolean;
allowedSchemesByTag?: { [index: string]: string[] } | boolean;
allowedSchemesAppliedToAttributes?: string[];
allowProtocolRelative?: boolean;
allowedTags?: string[] | boolean;
exclusiveFilter?: (frame: IFrame) => boolean;
nonTextTags?: string[];
selfClosing?: string[];
transformTags?: { [tagName: string]: string | Transformer };
parser?: Options;
}
var defaults: IDefaults;
function simpleTransform(tagName: string, attribs: Attributes, merge?: boolean): Transformer;
}
}

View File

@@ -1,369 +0,0 @@
// Generated by typings
// Source: node_modules/angular2-grid/directives/NgGrid.d.ts
declare module '~angular2-grid/directives/NgGrid' {
import { ElementRef, Renderer, EventEmitter, ComponentFactoryResolver, KeyValueDiffers, OnInit, OnDestroy, DoCheck, ViewContainerRef } from '@angular/core';
import { NgGridConfig, NgGridItemEvent, NgGridItemPosition, NgGridItemSize } from '~angular2-grid/interfaces/INgGrid';
import { NgGridItem } from '~angular2-grid/directives/NgGridItem';
export class NgGrid implements OnInit, DoCheck, OnDestroy {
private _differs;
private _ngEl;
private _renderer;
private componentFactoryResolver;
private _containerRef;
onDragStart: EventEmitter<NgGridItem>;
onDrag: EventEmitter<NgGridItem>;
onDragStop: EventEmitter<NgGridItem>;
onResizeStart: EventEmitter<NgGridItem>;
onResize: EventEmitter<NgGridItem>;
onResizeStop: EventEmitter<NgGridItem>;
onItemChange: EventEmitter<Array<NgGridItemEvent>>;
colWidth: number;
rowHeight: number;
minCols: number;
minRows: number;
marginTop: number;
marginRight: number;
marginBottom: number;
marginLeft: number;
isDragging: boolean;
isResizing: boolean;
autoStyle: boolean;
resizeEnable: boolean;
dragEnable: boolean;
cascade: string;
minWidth: number;
minHeight: number;
private _items;
private _draggingItem;
private _resizingItem;
private _resizeDirection;
private _itemGrid;
private _containerWidth;
private _containerHeight;
private _maxCols;
private _maxRows;
private _visibleCols;
private _visibleRows;
private _setWidth;
private _setHeight;
private _posOffset;
private _adding;
private _placeholderRef;
private _fixToGrid;
private _autoResize;
private _differ;
private _destroyed;
private _maintainRatio;
private _aspectRatio;
private _preferNew;
private _zoomOnDrag;
private _limitToScreen;
private _curMaxRow;
private _curMaxCol;
private _dragReady;
private _resizeReady;
private static CONST_DEFAULT_CONFIG;
private _config;
config: NgGridConfig;
constructor(_differs: KeyValueDiffers, _ngEl: ElementRef, _renderer: Renderer, componentFactoryResolver: ComponentFactoryResolver, _containerRef: ViewContainerRef);
ngOnInit(): void;
ngOnDestroy(): void;
setConfig(config: NgGridConfig): void;
getItemPosition(index: number): NgGridItemPosition;
getItemSize(index: number): NgGridItemSize;
ngDoCheck(): boolean;
setMargins(margins: Array<string>): void;
enableDrag(): void;
disableDrag(): void;
enableResize(): void;
disableResize(): void;
addItem(ngItem: NgGridItem): void;
removeItem(ngItem: NgGridItem): void;
updateItem(ngItem: NgGridItem): void;
triggerCascade(): void;
triggerResize(): void;
resizeEventHandler(e: any): void;
mouseDownEventHandler(e: MouseEvent): void;
mouseUpEventHandler(e: any): void;
mouseMoveEventHandler(e: any): void;
private updatePositionsAfterMaxChange();
private _calculateColWidth();
private _calculateRowHeight();
private _updateRatio();
private _applyChanges(changes);
private _resizeStart(e);
private _dragStart(e);
private _zoomOut();
private _resetZoom();
private _drag(e);
private _resize(e);
private _dragStop(e);
private _resizeStop(e);
private _maxGridSize(w, h);
private _calculateGridSize(width, height);
private _calculateGridPosition(left, top);
private _hasGridCollision(pos, dims);
private _getCollisions(pos, dims);
private _fixGridCollisions(pos, dims);
private _cascadeGrid(pos?, dims?);
private _fixGridPosition(pos, dims);
private _isWithinBoundsX(pos, dims);
private _fixPosToBoundsX(pos, dims);
private _fixSizeToBoundsX(pos, dims);
private _isWithinBoundsY(pos, dims);
private _fixPosToBoundsY(pos, dims);
private _fixSizeToBoundsY(pos, dims);
private _isWithinBounds(pos, dims);
private _fixPosToBounds(pos, dims);
private _fixSizeToBounds(pos, dims);
private _addToGrid(item);
private _removeFromGrid(item);
private _filterGrid();
private _updateSize();
private _getMaxRow();
private _getMaxCol();
private _getMousePosition(e);
private _getAbsoluteMousePosition(e);
private _getContainerColumns();
private _getContainerRows();
private _getItemFromPosition(position);
private _createPlaceholder(item);
private _emitOnItemChange();
}
}
declare module 'angular2-grid/directives/NgGrid' {
export * from '~angular2-grid/directives/NgGrid';
}
// Generated by typings
// Source: node_modules/angular2-grid/directives/NgGridItem.d.ts
declare module '~angular2-grid/directives/NgGridItem' {
import { NgGrid } from '~angular2-grid/directives/NgGrid';
import { NgGridItemConfig, NgGridItemEvent, NgGridItemPosition, NgGridItemSize, NgGridRawPosition, NgGridItemDimensions } from '~angular2-grid/interfaces/INgGrid';
import { ElementRef, Renderer, EventEmitter, KeyValueDiffers, OnInit, OnDestroy, ViewContainerRef } from '@angular/core';
export class NgGridItem implements OnInit, OnDestroy {
private _differs;
private _ngEl;
private _renderer;
private _ngGrid;
containerRef: ViewContainerRef;
onItemChange: EventEmitter<NgGridItemEvent>;
onDragStart: EventEmitter<NgGridItemEvent>;
onDrag: EventEmitter<NgGridItemEvent>;
onDragStop: EventEmitter<NgGridItemEvent>;
onDragAny: EventEmitter<NgGridItemEvent>;
onResizeStart: EventEmitter<NgGridItemEvent>;
onResize: EventEmitter<NgGridItemEvent>;
onResizeStop: EventEmitter<NgGridItemEvent>;
onResizeAny: EventEmitter<NgGridItemEvent>;
onChangeStart: EventEmitter<NgGridItemEvent>;
onChange: EventEmitter<NgGridItemEvent>;
onChangeStop: EventEmitter<NgGridItemEvent>;
onChangeAny: EventEmitter<NgGridItemEvent>;
ngGridItemChange: EventEmitter<NgGridItemConfig>;
private static CONST_DEFAULT_CONFIG;
isFixed: boolean;
isDraggable: boolean;
isResizable: boolean;
minWidth: number;
minHeight: number;
private _payload;
private _currentPosition;
private _size;
private _config;
private _dragHandle;
private _resizeHandle;
private _borderSize;
private _elemWidth;
private _elemHeight;
private _elemLeft;
private _elemTop;
private _added;
private _differ;
private _cascadeMode;
private _maxCols;
private _minCols;
private _maxRows;
private _minRows;
config: NgGridItemConfig;
readonly sizex: number;
readonly sizey: number;
readonly col: number;
readonly row: number;
readonly currentCol: number;
readonly currentRow: number;
constructor(_differs: KeyValueDiffers, _ngEl: ElementRef, _renderer: Renderer, _ngGrid: NgGrid, containerRef: ViewContainerRef);
onResizeStartEvent(): void;
onResizeEvent(): void;
onResizeStopEvent(): void;
onDragStartEvent(): void;
onDragEvent(): void;
onDragStopEvent(): void;
onCascadeEvent(): void;
ngOnInit(): void;
canDrag(e: any): boolean;
findHandle(handleSelector: string, startElement: HTMLElement): boolean;
canResize(e: any): string;
onMouseMove(e: any): void;
ngOnDestroy(): void;
getElement(): ElementRef;
getDragHandle(): string;
getResizeHandle(): string;
getDimensions(): NgGridItemDimensions;
getSize(): NgGridItemSize;
getPosition(): NgGridRawPosition;
getGridPosition(): NgGridItemPosition;
setConfig(config: NgGridItemConfig): void;
ngDoCheck(): boolean;
setSize(newSize: NgGridItemSize, update?: boolean): void;
setGridPosition(gridPosition: NgGridItemPosition, update?: boolean): void;
getEventOutput(): NgGridItemEvent;
setPosition(x: number, y: number): void;
setCascadeMode(cascade: string): void;
setDimensions(w: number, h: number): void;
startMoving(): void;
stopMoving(): void;
recalculateSelf(): void;
fixResize(newSize: NgGridItemSize): NgGridItemSize;
private elementMatches(element, selector);
private _recalculatePosition();
private _recalculateDimensions();
private _getMousePosition(e);
private _applyChanges(changes);
}
}
declare module 'angular2-grid/directives/NgGridItem' {
export * from '~angular2-grid/directives/NgGridItem';
}
// Generated by typings
// Source: node_modules/angular2-grid/components/NgGridPlaceholder.d.ts
declare module '~angular2-grid/components/NgGridPlaceholder' {
import { NgGrid } from '~angular2-grid/directives/NgGrid';
import { NgGridItemPosition, NgGridItemSize } from '~angular2-grid/interfaces/INgGrid';
import { ElementRef, Renderer, OnInit } from '@angular/core';
export class NgGridPlaceholder implements OnInit {
private _ngEl;
private _renderer;
private _size;
private _position;
private _ngGrid;
private _cascadeMode;
constructor(_ngEl: ElementRef, _renderer: Renderer);
registerGrid(ngGrid: NgGrid): void;
ngOnInit(): void;
setSize(newSize: NgGridItemSize): void;
setGridPosition(newPosition: NgGridItemPosition): void;
setCascadeMode(cascade: string): void;
private _setDimensions(w, h);
private _setPosition(x, y);
private _recalculatePosition();
private _recalculateDimensions();
}
}
declare module 'angular2-grid/components/NgGridPlaceholder' {
export * from '~angular2-grid/components/NgGridPlaceholder';
}
// Generated by typings
// Source: node_modules/angular2-grid/interfaces/INgGrid.d.ts
declare module '~angular2-grid/interfaces/INgGrid' {
export interface NgGridConfig {
margins?: number[];
draggable?: boolean;
resizable?: boolean;
max_cols?: number;
max_rows?: number;
visible_cols?: number;
visible_rows?: number;
min_cols?: number;
min_rows?: number;
col_width?: number;
row_height?: number;
cascade?: string;
min_width?: number;
min_height?: number;
fix_to_grid?: boolean;
auto_style?: boolean;
auto_resize?: boolean;
maintain_ratio?: boolean;
prefer_new?: boolean;
zoom_on_drag?: boolean;
limit_to_screen?: boolean;
}
export interface NgGridItemConfig {
payload?: any;
col?: number;
row?: number;
sizex?: number;
sizey?: number;
dragHandle?: string;
resizeHandle?: string;
fixed?: boolean;
draggable?: boolean;
resizable?: boolean;
borderSize?: number;
maxCols?: number;
minCols?: number;
maxRows?: number;
minRows?: number;
minWidth?: number;
minHeight?: number;
}
export interface NgGridItemEvent {
payload: any;
col: number;
row: number;
sizex: number;
sizey: number;
width: number;
height: number;
left: number;
top: number;
}
export interface NgGridItemSize {
x: number;
y: number;
}
export interface NgGridItemPosition {
col: number;
row: number;
}
export interface NgGridRawPosition {
left: number;
top: number;
}
export interface NgGridItemDimensions {
width: number;
height: number;
}
}
declare module 'angular2-grid/interfaces/INgGrid' {
export * from '~angular2-grid/interfaces/INgGrid';
}
// Generated by typings
// Source: node_modules/angular2-grid/modules/NgGrid.module.d.ts
declare module '~angular2-grid/modules/NgGrid.module' {
export class NgGridModule {
}
}
declare module 'angular2-grid/modules/NgGrid.module' {
export * from '~angular2-grid/modules/NgGrid.module';
}
// Generated by typings
// Source: node_modules/angular2-grid/main.d.ts
declare module '~angular2-grid/main' {
export * from '~angular2-grid/directives/NgGrid';
export * from '~angular2-grid/directives/NgGridItem';
export * from '~angular2-grid/components/NgGridPlaceholder';
export * from '~angular2-grid/interfaces/INgGrid';
export * from '~angular2-grid/modules/NgGrid.module';
}
declare module 'angular2-grid/main' {
export * from '~angular2-grid/main';
}
declare module 'angular2-grid' {
export * from '~angular2-grid/main';
}

View File

@@ -1,196 +0,0 @@
// Generated by typings
// Source: ../node_modules/angular2-slickgrid/out/js/interfaces.d.ts
declare module '~angular2-slickgrid/out/js/interfaces' {
import { Observable } from 'rxjs/Rx';
export enum NotificationType {
Error = 0,
UpdateAvailable = 1,
UpdateDownloaded = 2,
}
export interface ISelectionRange {
startRow: number;
endRow: number;
startColumn: number;
endColumn: number;
}
export enum CollectionChange {
ItemsReplaced = 0,
}
export interface IObservableCollection<T> {
getLength(): number;
at(index: number): T;
getRange(start: number, end: number): T[];
setCollectionChangedCallback(callback: (change: CollectionChange, startIndex: number, count: number) => void): void;
resetWindowsAroundIndex(index: number): void;
}
export class CancellationToken {
private _isCanceled;
private _canceled;
cancel(): void;
readonly isCanceled: boolean;
readonly canceled: Observable<any>;
}
export interface IGridColumnDefinition {
id: string;
type: number;
}
export interface ISlickColumn<T> extends Slick.Column<T> {
isEditable?: boolean;
}
}
declare module 'angular2-slickgrid/out/js/interfaces' {
export * from '~angular2-slickgrid/out/js/interfaces';
}
// Generated by typings
// Source: ../node_modules/angular2-slickgrid/out/js/selectionModel.d.ts
declare module '~angular2-slickgrid/out/js/selectionModel' {
import { ISelectionRange } from '~angular2-slickgrid/out/js/interfaces';
export class SelectionModel implements ISlickSelectionModel {
private _rowSelectionModel;
private _handler;
private _onSelectedRangesChanged;
private _slickRangeFactory;
constructor(_rowSelectionModel: ISlickSelectionModel, _handler: ISlickEventHandler, _onSelectedRangesChanged: ISlickEvent, _slickRangeFactory: (fromRow: number, fromCell: number, toRow: number, toCell: number) => Slick.Range);
readonly range: Slick.Range[];
readonly onSelectedRangesChanged: ISlickEvent;
init(grid: ISlickGrid): void;
destroy(): void;
setSelectedRanges(ranges: Slick.Range[]): void;
getSelectedRanges(): Slick.Range[];
changeSelectedRanges(selections: ISelectionRange[]): void;
toggleSingleColumnSelection(columnId: string): void;
setSingleColumnSelection(columnId: string): void;
toggleMultiColumnSelection(columnId: string): void;
extendMultiColumnSelection(columnId: string): void;
clearSelection(): void;
private _grid;
private _ranges;
private _lastSelectedColumnIndexSequence;
private static areRangesIdentical(lhs, rhs);
private getColumnRange(columnId);
private getColumnRangeByIndex(columnIndex);
private readonly isColumnSelectionCurrently;
private updateSelectedRanges(ranges);
}
export interface ISlickSelectionModel {
range: Slick.Range[];
onSelectedRangesChanged: any;
init(grid: any): void;
destroy(): void;
setSelectedRanges(ranges: Slick.Range[]): void;
getSelectedRanges(): Slick.Range[];
}
export interface ISlickEventHandler {
subscribe(event: any, handler: any): void;
unsubscribeAll(): void;
}
export interface ISlickEvent {
notify(eventData: Slick.Range[]): void;
subscribe(handler: (e: any, args: any) => void): void;
}
export interface ISlickGrid {
getActiveCellNode(): any;
getCanvasNode(): any;
resetActiveCell(): void;
focus(): void;
getColumnIndex(columnId: string): number;
getDataLength(): number;
}
}
declare module 'angular2-slickgrid/out/js/selectionModel' {
export * from '~angular2-slickgrid/out/js/selectionModel';
}
// Generated by typings
// Source: ../node_modules/angular2-slickgrid/out/js/slickGrid.d.ts
declare module '~angular2-slickgrid/out/js/slickGrid' {
import { OnChanges, OnInit, OnDestroy, SimpleChange, EventEmitter, AfterViewInit } from '@angular/core';
import { Observable } from 'rxjs/Rx';
import { IObservableCollection, ISlickColumn } from '~angular2-slickgrid/out/js/interfaces';
export function getOverridableTextEditorClass(grid: SlickGrid): any;
export class SlickGrid implements OnChanges, OnInit, OnDestroy, AfterViewInit {
private _el;
columnDefinitions: ISlickColumn<any>[];
dataRows: IObservableCollection<{}>;
resized: Observable<any>;
highlightedCells: {
row: number;
column: number;
}[];
blurredColumns: string[];
contextColumns: string[];
columnsLoading: string[];
showHeader: boolean;
enableColumnReorder: boolean;
enableAsyncPostRender: boolean;
selectionModel: string | Slick.SelectionModel<any, any>;
plugins: Array<string | Slick.Plugin<any>>;
enableEditing: boolean;
topRowNumber: number;
overrideCellFn: (rowNumber: number, columnId: number, value?: any, data?: any) => string;
isCellEditValid: (row: number, column: number, newValue: any) => boolean;
onBeforeAppendCell: (row: number, column: number) => string;
loadFinished: EventEmitter<void>;
onContextMenu: EventEmitter<Slick.EventData>;
onScroll: EventEmitter<Slick.OnScrollEventArgs<any>>;
onActiveCellChanged: EventEmitter<Slick.OnActiveCellChangedEventArgs<any>>;
onBeforeEditCell: EventEmitter<Slick.OnBeforeEditCellEventArgs<any>>;
onCellChange: EventEmitter<Slick.OnCellChangeEventArgs<any>>;
onRendered: EventEmitter<Slick.OnRenderedEventArgs<any>>;
onFocus(): void;
rowHeight: number;
constructor(_el: any);
ngOnChanges(changes: {
[propName: string]: SimpleChange;
}): void;
ngOnInit(): void;
ngAfterViewInit(): void;
ngOnDestroy(): void;
enterEditSession(): void;
endEditSession(): void;
readonly onSelectedRowsChanged: Slick.Event<Slick.OnSelectedRowsChangedEventArgs<any>>;
getSelectedRows(): number[];
getColumnIndex(name: string): number;
getSelectedRanges(): Slick.Range[];
registerPlugin(plugin: Slick.Plugin<any> | string): void;
setActive(): void;
selection: Slick.Range[] | boolean;
readonly activeCell: Slick.Cell;
}
}
declare module 'angular2-slickgrid/out/js/slickGrid' {
export * from '~angular2-slickgrid/out/js/slickGrid';
}
// Generated by typings
// Source: ../node_modules/angular2-slickgrid/out/js/virtualizedCollection.d.ts
declare module '~angular2-slickgrid/out/js/virtualizedCollection' {
import { IObservableCollection, CollectionChange } from '~angular2-slickgrid/out/js/interfaces';
export class VirtualizedCollection<TData> implements IObservableCollection<TData> {
constructor(windowSize: number, length: number, loadFn: (offset: number, count: number) => Promise<TData[]>, _placeHolderGenerator: (index: number) => TData);
setCollectionChangedCallback(callback: (change: CollectionChange, startIndex: number, count: number) => void): void;
getLength(): number;
at(index: number): TData;
getRange(start: number, end: number): TData[];
resetWindowsAroundIndex(index: number): void;
}
}
declare module 'angular2-slickgrid/out/js/virtualizedCollection' {
export * from '~angular2-slickgrid/out/js/virtualizedCollection';
}
// Generated by typings
// Source: ../node_modules/angular2-slickgrid/out/index.d.ts
declare module '~angular2-slickgrid/out/index' {
export * from '~angular2-slickgrid/out/js/interfaces';
export * from '~angular2-slickgrid/out/js/selectionModel';
export * from '~angular2-slickgrid/out/js/slickGrid';
export * from '~angular2-slickgrid/out/js/virtualizedCollection';
}
declare module 'angular2-slickgrid/out/index' {
export * from '~angular2-slickgrid/out/index';
}
declare module 'angular2-slickgrid' {
export * from '~angular2-slickgrid/out/index';
}

View File

@@ -1,50 +0,0 @@
// Generated by typings
// Source: node_modules/ansi_up/dist/ansi_up.d.ts
declare module 'ansi_up' {
export interface AU_Color {
rgb: number[];
class_name: string;
}
export interface TextWithAttr {
fg: AU_Color;
bg: AU_Color;
bold: boolean;
text: string;
}
export interface Formatter {
transform(fragment: TextWithAttr, instance: AnsiUp): any;
compose(segments: any[], instance: AnsiUp): any;
}
function rgx(tmplObj: any, ...subst: any[]): RegExp;
export default class AnsiUp {
VERSION: string;
ansi_colors: {
rgb: number[];
class_name: string;
}[][];
htmlFormatter: Formatter;
textFormatter: Formatter;
private palette_256;
private fg;
private bg;
private bold;
private _use_classes;
private _escape_for_html;
private _sgr_regex;
private _buffer;
constructor();
use_classes: boolean;
escape_for_html: boolean;
private setup_256_palette();
private old_escape_for_html(txt);
private old_linkify(txt);
private detect_incomplete_ansi(txt);
private detect_incomplete_link(txt);
ansi_to(txt: string, formatter: Formatter): any;
ansi_to_html(txt: string): string;
ansi_to_text(txt: string): string;
private with_state(text);
private handle_incomplete_sequences(chunks);
private process_ansi(block);
}
}

View File

@@ -1,668 +0,0 @@
// Type definitions for Chart.js 2.7
// Project: https://github.com/nnnick/Chart.js
// Definitions by: Alberto Nuti <https://github.com/anuti>
// Fabien Lavocat <https://github.com/FabienLavocat>
// KentarouTakeda <https://github.com/KentarouTakeda>
// Larry Bahr <https://github.com/larrybahr>
// Daniel Luz <https://github.com/mernen>
// Joseph Page <https://github.com/josefpaij>
// Dan Manastireanu <https://github.com/danmana>
// Guillaume Rodriguez <https://github.com/guillaume-ro-fr>
// Sergey Rubanov <https://github.com/chicoxyzzy>
// Simon Archer <https://github.com/archy-bold>
// Ken Elkabany <https://github.com/braincore>
// Slavik Nychkalo <https://github.com/gebeto>
// Francesco Benedetto <https://github.com/frabnt>
// Alexandros Dorodoulis <https://github.com/alexdor>
// Manuel Heidrich <https://github.com/mahnuh>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.3
declare module 'chart.js' {
export class Chart {
static readonly Chart: typeof Chart;
constructor(
context: string | CanvasRenderingContext2D | HTMLCanvasElement | ArrayLike<CanvasRenderingContext2D | HTMLCanvasElement>,
options: Chart.ChartConfiguration
);
config: Chart.ChartConfiguration;
data: Chart.ChartData;
destroy: () => {};
update: (duration?: any, lazy?: any) => {};
render: (duration?: any, lazy?: any) => {};
stop: () => {};
resize: () => {};
clear: () => {};
options: Chart.ChartOptions;
toBase64Image: () => string;
generateLegend: () => {};
getElementAtEvent: (e: any) => {};
getElementsAtEvent: (e: any) => Array<{}>;
getDatasetAtEvent: (e: any) => Array<{}>;
getDatasetMeta: (index: number) => Meta;
ctx: CanvasRenderingContext2D | null;
canvas: HTMLCanvasElement | null;
chartArea: Chart.ChartArea;
static pluginService: PluginServiceStatic;
static plugins: PluginServiceStatic;
static defaults: {
global: Chart.ChartOptions & Chart.ChartFontOptions;
[key: string]: any;
};
static controllers: {
[key: string]: any;
};
static helpers: {
[key: string]: any;
};
// Tooltip Static Options
static Tooltip: Chart.ChartTooltipsStaticConfiguration;
}
export class PluginServiceStatic {
register(plugin: PluginServiceGlobalRegistration & PluginServiceRegistrationOptions): void;
unregister(plugin: PluginServiceGlobalRegistration & PluginServiceRegistrationOptions): void;
}
interface PluginServiceGlobalRegistration {
id?: string;
}
interface PluginServiceRegistrationOptions {
beforeInit?(chartInstance: Chart, options?: any): void;
afterInit?(chartInstance: Chart, options?: any): void;
beforeUpdate?(chartInstance: Chart, options?: any): void;
afterUpdate?(chartInstance: Chart, options?: any): void;
beforeLayout?(chartInstance: Chart, options?: any): void;
afterLayout?(chartInstance: Chart, options?: any): void;
beforeDatasetsUpdate?(chartInstance: Chart, options?: any): void;
afterDatasetsUpdate?(chartInstance: Chart, options?: any): void;
beforeDatasetUpdate?(chartInstance: Chart, options?: any): void;
afterDatasetUpdate?(chartInstance: Chart, options?: any): void;
// This is called at the start of a render. It is only called once, even if the animation will run for a number of frames. Use beforeDraw or afterDraw
// to do something on each animation frame
beforeRender?(chartInstance: Chart, options?: any): void;
afterRender?(chartInstance: Chart, options?: any): void;
// Easing is for animation
beforeDraw?(chartInstance: Chart, easing: string, options?: any): void;
afterDraw?(chartInstance: Chart, easing: string, options?: any): void;
// Before the datasets are drawn but after scales are drawn
beforeDatasetsDraw?(chartInstance: Chart, easing: string, options?: any): void;
afterDatasetsDraw?(chartInstance: Chart, easing: string, options?: any): void;
beforeDatasetDraw?(chartInstance: Chart, easing: string, options?: any): void;
afterDatasetDraw?(chartInstance: Chart, easing: string, options?: any): void;
// Called before drawing the `tooltip`. If any plugin returns `false`,
// the tooltip drawing is cancelled until another `render` is triggered.
beforeTooltipDraw?(chartInstance: Chart, tooltipData?: any, options?: any): void;
// Called after drawing the `tooltip`. Note that this hook will not,
// be called if the tooltip drawing has been previously cancelled.
afterTooltipDraw?(chartInstance: Chart, tooltipData?: any, options?: any): void;
// Called when an event occurs on the chart
beforeEvent?(chartInstance: Chart, event: Event, options?: any): void;
afterEvent?(chartInstance: Chart, event: Event, options?: any): void;
resize?(chartInstance: Chart, newChartSize: Chart.ChartSize, options?: any): void;
destroy?(chartInstance: Chart): void;
/** @deprecated since version 2.5.0. Use `afterLayout` instead. */
afterScaleUpdate?(chartInstance: Chart, options?: any): void;
}
interface Meta {
type: Chart.ChartType;
data: MetaData[];
dataset?: Chart.ChartDataSets;
controller: { [key: string]: any; };
hidden?: boolean;
total?: string;
xAxisID?: string;
yAxisID?: string;
"$filler"?: { [key: string]: any; };
}
interface MetaData {
_chart: Chart;
_datasetIndex: number;
_index: number;
_model: Model;
_start?: any;
_view: Model;
_xScale: Chart.ChartScales;
_yScale: Chart.ChartScales;
hidden?: boolean;
}
interface Model {
backgroundColor: string;
borderColor: string;
borderWidth?: number;
controlPointNextX: number;
controlPointNextY: number;
controlPointPreviousX: number;
controlPointPreviousY: number;
hitRadius: number;
pointStyle: string;
radius: string;
skip?: boolean;
steppedLine?: undefined;
tension: number;
x: number;
y: number;
}
export namespace Chart {
type ChartType = 'line' | 'bar' | 'horizontalBar' | 'radar' | 'doughnut' | 'polarArea' | 'bubble' | 'pie';
type TimeUnit = 'millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
type ScaleType = 'category' | 'linear' | 'logarithmic' | 'time' | 'radialLinear';
type PointStyle = 'circle' | 'cross' | 'crossRot' | 'dash' | 'line' | 'rect' | 'rectRounded' | 'rectRot' | 'star' | 'triangle';
type PositionType = 'left' | 'right' | 'top' | 'bottom';
interface ChartArea {
top: number;
right: number;
bottom: number;
left: number;
}
interface ChartLegendItem {
text?: string;
fillStyle?: string;
hidden?: boolean;
lineCap?: string;
lineDash?: number[];
lineDashOffset?: number;
lineJoin?: string;
lineWidth?: number;
strokeStyle?: string;
pointStyle?: PointStyle;
}
interface ChartLegendLabelItem extends ChartLegendItem {
datasetIndex: number;
}
interface ChartTooltipItem {
xLabel?: string;
yLabel?: string;
datasetIndex?: number;
index?: number;
}
interface ChartTooltipLabelColor {
borderColor: ChartColor;
backgroundColor: ChartColor;
}
interface ChartTooltipCallback {
beforeTitle?(item: ChartTooltipItem[], data: ChartData): string | string[];
title?(item: ChartTooltipItem[], data: ChartData): string | string[];
afterTitle?(item: ChartTooltipItem[], data: ChartData): string | string[];
beforeBody?(item: ChartTooltipItem[], data: ChartData): string | string[];
beforeLabel?(tooltipItem: ChartTooltipItem, data: ChartData): string | string[];
label?(tooltipItem: ChartTooltipItem, data: ChartData): string | string[];
labelColor?(tooltipItem: ChartTooltipItem, chart: Chart): ChartTooltipLabelColor;
labelTextColor?(tooltipItem: ChartTooltipItem, chart: Chart): string;
afterLabel?(tooltipItem: ChartTooltipItem, data: ChartData): string | string[];
afterBody?(item: ChartTooltipItem[], data: ChartData): string | string[];
beforeFooter?(item: ChartTooltipItem[], data: ChartData): string | string[];
footer?(item: ChartTooltipItem[], data: ChartData): string | string[];
afterFooter?(item: ChartTooltipItem[], data: ChartData): string | string[];
}
interface ChartAnimationParameter {
chartInstance?: any;
animationObject?: any;
}
interface ChartPoint {
x?: number | string | Date;
y?: number | string | Date;
r?: number;
t?: number | string | Date;
}
interface ChartConfiguration {
type?: ChartType | string;
data?: ChartData;
options?: ChartOptions;
plugins?: PluginServiceRegistrationOptions[];
}
interface ChartData {
labels?: Array<string | string[]>;
datasets?: ChartDataSets[];
}
interface RadialChartOptions extends ChartOptions {
scale?: RadialLinearScale;
}
interface ChartSize {
height: number;
width: number;
}
interface ChartOptions {
responsive?: boolean;
responsiveAnimationDuration?: number;
aspectRatio?: number;
maintainAspectRatio?: boolean;
events?: string[];
onHover?(this: Chart, event: MouseEvent, activeElements: Array<{}>): any;
onClick?(event?: MouseEvent, activeElements?: Array<{}>): any;
onResize?(this: Chart, newSize: ChartSize): void;
title?: ChartTitleOptions;
legend?: ChartLegendOptions;
tooltips?: ChartTooltipOptions;
hover?: ChartHoverOptions;
animation?: ChartAnimationOptions;
elements?: ChartElementsOptions;
layout?: ChartLayoutOptions;
scales?: ChartScales;
showLines?: boolean;
spanGaps?: boolean;
cutoutPercentage?: number;
circumference?: number;
rotation?: number;
devicePixelRatio?: number;
// Plugins can require any options
plugins?: { [pluginId: string]: any };
}
interface ChartFontOptions {
defaultFontColor?: ChartColor;
defaultFontFamily?: string;
defaultFontSize?: number;
defaultFontStyle?: string;
}
interface ChartTitleOptions {
display?: boolean;
position?: PositionType;
fullWidth?: boolean;
fontSize?: number;
fontFamily?: string;
fontColor?: ChartColor;
fontStyle?: string;
padding?: number;
text?: string | string[];
}
interface ChartLegendOptions {
display?: boolean;
position?: PositionType;
fullWidth?: boolean;
onClick?(event: MouseEvent, legendItem: ChartLegendLabelItem): void;
onHover?(event: MouseEvent, legendItem: ChartLegendLabelItem): void;
labels?: ChartLegendLabelOptions;
reverse?: boolean;
}
interface ChartLegendLabelOptions {
boxWidth?: number;
fontSize?: number;
fontStyle?: string;
fontColor?: ChartColor;
fontFamily?: string;
padding?: number;
generateLabels?(chart: any): any;
filter?(legendItem: ChartLegendLabelItem, data: ChartData): any;
usePointStyle?: boolean;
}
interface ChartTooltipOptions {
enabled?: boolean;
custom?(a: any): void;
mode?: string;
intersect?: boolean;
backgroundColor?: ChartColor;
titleFontFamily?: string;
titleFontSize?: number;
titleFontStyle?: string;
titleFontColor?: ChartColor;
titleSpacing?: number;
titleMarginBottom?: number;
bodyFontFamily?: string;
bodyFontSize?: number;
bodyFontStyle?: string;
bodyFontColor?: ChartColor;
bodySpacing?: number;
footerFontFamily?: string;
footerFontSize?: number;
footerFontStyle?: string;
footerFontColor?: ChartColor;
footerSpacing?: number;
footerMarginTop?: number;
xPadding?: number;
yPadding?: number;
caretSize?: number;
cornerRadius?: number;
multiKeyBackground?: string;
callbacks?: ChartTooltipCallback;
filter?(item: ChartTooltipItem): boolean;
itemSort?(itemA: ChartTooltipItem, itemB: ChartTooltipItem): number;
position?: string;
caretPadding?: number;
displayColors?: boolean;
borderColor?: ChartColor;
borderWidth?: number;
}
interface ChartTooltipsStaticConfiguration {
positioners: { [mode: string]: ChartTooltipPositioner };
}
type ChartTooltipPositioner = (elements: any[], eventPosition: Point) => Point;
interface ChartHoverOptions {
mode?: string;
animationDuration?: number;
intersect?: boolean;
onHover?(this: Chart, event: MouseEvent, activeElements: Array<{}>): any;
}
interface ChartAnimationObject {
currentStep?: number;
numSteps?: number;
easing?: string;
render?(arg: any): void;
onAnimationProgress?(arg: any): void;
onAnimationComplete?(arg: any): void;
}
interface ChartAnimationOptions {
duration?: number;
easing?: string;
onProgress?(chart: any): void;
onComplete?(chart: any): void;
}
interface ChartElementsOptions {
point?: ChartPointOptions;
line?: ChartLineOptions;
arc?: ChartArcOptions;
rectangle?: ChartRectangleOptions;
}
interface ChartArcOptions {
backgroundColor?: ChartColor;
borderColor?: ChartColor;
borderWidth?: number;
}
interface ChartLineOptions {
tension?: number;
backgroundColor?: ChartColor;
borderWidth?: number;
borderColor?: ChartColor;
borderCapStyle?: string;
borderDash?: any[];
borderDashOffset?: number;
borderJoinStyle?: string;
capBezierPoints?: boolean;
fill?: 'zero' | 'top' | 'bottom' | boolean;
stepped?: boolean;
}
interface ChartPointOptions {
radius?: number;
pointStyle?: PointStyle;
backgroundColor?: ChartColor;
borderWidth?: number;
borderColor?: ChartColor;
hitRadius?: number;
hoverRadius?: number;
hoverBorderWidth?: number;
}
interface ChartRectangleOptions {
backgroundColor?: ChartColor;
borderWidth?: number;
borderColor?: ChartColor;
borderSkipped?: string;
}
interface ChartLayoutOptions {
padding?: ChartLayoutPaddingObject | number;
}
interface ChartLayoutPaddingObject {
top?: number;
right?: number;
bottom?: number;
left?: number;
}
interface GridLineOptions {
display?: boolean;
color?: ChartColor;
borderDash?: number[];
borderDashOffset?: number;
lineWidth?: number;
drawBorder?: boolean;
drawOnChartArea?: boolean;
drawTicks?: boolean;
tickMarkLength?: number;
zeroLineWidth?: number;
zeroLineColor?: ChartColor;
zeroLineBorderDash?: number[];
zeroLineBorderDashOffset?: number;
offsetGridLines?: boolean;
}
interface ScaleTitleOptions {
display?: boolean;
labelString?: string;
fontColor?: ChartColor;
fontFamily?: string;
fontSize?: number;
fontStyle?: string;
}
interface TickOptions {
autoSkip?: boolean;
autoSkipPadding?: number;
backdropColor?: ChartColor;
backdropPaddingX?: number;
backdropPaddingY?: number;
beginAtZero?: boolean;
callback?(value: any, index: any, values: any): string | number;
display?: boolean;
fontColor?: ChartColor;
fontFamily?: string;
fontSize?: number;
fontStyle?: string;
labelOffset?: number;
max?: any;
maxRotation?: number;
maxTicksLimit?: number;
min?: any;
minRotation?: number;
mirror?: boolean;
padding?: number;
reverse?: boolean;
showLabelBackdrop?: boolean;
source?: 'auto' | 'data' | 'labels';
}
interface AngleLineOptions {
display?: boolean;
color?: ChartColor;
lineWidth?: number;
}
interface PointLabelOptions {
callback?(arg: any): any;
fontColor?: ChartColor;
fontFamily?: string;
fontSize?: number;
fontStyle?: string;
}
interface LinearTickOptions extends TickOptions {
maxTicksLimit?: number;
stepSize?: number;
suggestedMin?: number;
suggestedMax?: number;
}
// tslint:disable-next-line no-empty-interface
interface LogarithmicTickOptions extends TickOptions {
}
type ChartColor = string | CanvasGradient | CanvasPattern | string[];
interface ChartDataSets {
cubicInterpolationMode?: 'default' | 'monotone';
backgroundColor?: ChartColor | ChartColor[];
borderWidth?: number | number[];
borderColor?: ChartColor | ChartColor[];
borderCapStyle?: string;
borderDash?: number[];
borderDashOffset?: number;
borderJoinStyle?: string;
borderSkipped?: PositionType;
data?: number[] | ChartPoint[];
fill?: boolean | number | string;
hoverBackgroundColor?: string | string[];
hoverBorderColor?: string | string[];
hoverBorderWidth?: number | number[];
label?: string;
lineTension?: number;
steppedLine?: 'before' | 'after' | boolean;
pointBorderColor?: ChartColor | ChartColor[];
pointBackgroundColor?: ChartColor | ChartColor[];
pointBorderWidth?: number | number[];
pointRadius?: number | number[];
pointHoverRadius?: number | number[];
pointHitRadius?: number | number[];
pointHoverBackgroundColor?: ChartColor | ChartColor[];
pointHoverBorderColor?: ChartColor | ChartColor[];
pointHoverBorderWidth?: number | number[];
pointStyle?: PointStyle | HTMLImageElement | HTMLCanvasElement | Array<PointStyle | HTMLImageElement | HTMLCanvasElement>;
xAxisID?: string;
yAxisID?: string;
type?: string;
hidden?: boolean;
hideInLegendAndTooltip?: boolean;
showLine?: boolean;
stack?: string;
spanGaps?: boolean;
}
interface ChartScales {
type?: ScaleType | string;
display?: boolean;
position?: PositionType | string;
gridLines?: GridLineOptions;
scaleLabel?: ScaleTitleOptions;
ticks?: TickOptions;
xAxes?: ChartXAxe[];
yAxes?: ChartYAxe[];
}
interface CommonAxe {
bounds?: string;
type?: ScaleType | string;
display?: boolean;
id?: string;
stacked?: boolean;
position?: string;
ticks?: TickOptions;
gridLines?: GridLineOptions;
barThickness?: number | "flex";
maxBarThickness?: number;
scaleLabel?: ScaleTitleOptions;
time?: TimeScale;
offset?: boolean;
beforeUpdate?(scale?: any): void;
beforeSetDimension?(scale?: any): void;
beforeDataLimits?(scale?: any): void;
beforeBuildTicks?(scale?: any): void;
beforeTickToLabelConversion?(scale?: any): void;
beforeCalculateTickRotation?(scale?: any): void;
beforeFit?(scale?: any): void;
afterUpdate?(scale?: any): void;
afterSetDimension?(scale?: any): void;
afterDataLimits?(scale?: any): void;
afterBuildTicks?(scale?: any): void;
afterTickToLabelConversion?(scale?: any): void;
afterCalculateTickRotation?(scale?: any): void;
afterFit?(scale?: any): void;
}
interface ChartXAxe extends CommonAxe {
categoryPercentage?: number;
barPercentage?: number;
distribution?: 'linear' | 'series';
}
// tslint:disable-next-line no-empty-interface
interface ChartYAxe extends CommonAxe {
}
interface LinearScale extends ChartScales {
ticks?: LinearTickOptions;
}
interface LogarithmicScale extends ChartScales {
ticks?: LogarithmicTickOptions;
}
interface TimeDisplayFormat {
millisecond?: string;
second?: string;
minute?: string;
hour?: string;
day?: string;
week?: string;
month?: string;
quarter?: string;
year?: string;
}
interface TimeScale extends ChartScales {
displayFormats?: TimeDisplayFormat;
isoWeekday?: boolean;
max?: string;
min?: string;
parser?: string | ((arg: any) => any);
round?: TimeUnit;
tooltipFormat?: string;
unit?: TimeUnit;
unitStepSize?: number;
stepSize?: number;
minUnit?: TimeUnit;
}
interface RadialLinearScale extends LinearScale {
lineArc?: boolean;
angleLines?: AngleLineOptions;
pointLabels?: PointLabelOptions;
ticks?: TickOptions;
}
interface Point {
x: number;
y: number;
}
}
}

View File

@@ -1,54 +0,0 @@
// Generated by typings
// Source: node_modules/html-query-plan/dist/interfaces.d.ts
declare module '~html-query-plan/dist/interfaces' {
export interface IQpOptions {
jsTooltips?: boolean;
}
export interface ICoordinate {
x: number;
y: number;
}
}
declare module 'html-query-plan/dist/interfaces' {
export * from '~html-query-plan/dist/interfaces';
}
// Generated by typings
// Source: node_modules/html-query-plan/dist/svgLines.d.ts
declare module '~html-query-plan/dist/svgLines' {
/**
*
* @param container
*/
export function drawSvgLines(container: HTMLElement): void;
}
declare module 'html-query-plan/dist/svgLines' {
export * from '~html-query-plan/dist/svgLines';
}
// Generated by typings
// Source: node_modules/html-query-plan/dist/index.d.ts
declare module '~html-query-plan/dist/index' {
import { IQpOptions } from '~html-query-plan/dist/interfaces';
export { drawSvgLines } from '~html-query-plan/dist/svgLines';
export * from '~html-query-plan/dist/interfaces';
/**
*
* @param container
* @param planXml
* @param options
*/
export function showPlan(container: HTMLElement, planXml: string, options: IQpOptions): void;
/**
*
* @param options
* @param defaults
*/
export function setDefaults<T>(options: any, defaults: any): T;
}
declare module 'html-query-plan/dist/index' {
export * from '~html-query-plan/dist/index';
}
declare module 'html-query-plan' {
export * from '~html-query-plan/dist/index';
}

View File

@@ -1,82 +0,0 @@
// Generated by typings
// Source: node_modules/ng2-charts/charts/charts.d.ts
declare module '~ng2-charts/charts/charts' {
import { OnDestroy, OnInit, OnChanges, EventEmitter, ElementRef, SimpleChanges } from '@angular/core';
export class BaseChartDirective implements OnDestroy, OnChanges, OnInit {
static defaultColors: Array<number[]>;
data: number[] | any[];
datasets: any[];
labels: Array<any>;
options: any;
chartType: string;
colors: Array<any>;
legend: boolean;
chartClick: EventEmitter<any>;
chartHover: EventEmitter<any>;
ctx: any;
chart: any;
private cvs;
private initFlag;
private element;
constructor(element: ElementRef);
ngOnInit(): any;
ngOnChanges(changes: SimpleChanges): void;
ngOnDestroy(): any;
getChartBuilder(ctx: any): any;
private updateChartData(newDataValues);
private getDatasets();
private refresh();
}
export interface Color {
backgroundColor?: string | string[];
borderWidth?: number | number[];
borderColor?: string | string[];
borderCapStyle?: string;
borderDash?: number[];
borderDashOffset?: number;
borderJoinStyle?: string;
pointBorderColor?: string | string[];
pointBackgroundColor?: string | string[];
pointBorderWidth?: number | number[];
pointRadius?: number | number[];
pointHoverRadius?: number | number[];
pointHitRadius?: number | number[];
pointHoverBackgroundColor?: string | string[];
pointHoverBorderColor?: string | string[];
pointHoverBorderWidth?: number | number[];
pointStyle?: string | string[];
hoverBackgroundColor?: string | string[];
hoverBorderColor?: string | string[];
hoverBorderWidth?: number;
}
export interface Colors extends Color {
data?: number[];
label?: string;
}
export class ChartsModule {
}
}
declare module 'ng2-charts/charts/charts' {
export * from '~ng2-charts/charts/charts';
}
// Generated by typings
// Source: node_modules/ng2-charts/index.d.ts
declare module '~ng2-charts/index' {
export * from '~ng2-charts/charts/charts';
}
declare module 'ng2-charts/index' {
export * from '~ng2-charts/index';
}
// Generated by typings
// Source: node_modules/ng2-charts/ng2-charts.d.ts
declare module '~ng2-charts/ng2-charts' {
export * from '~ng2-charts/index';
}
declare module 'ng2-charts/ng2-charts' {
export * from '~ng2-charts/ng2-charts';
}
declare module 'ng2-charts' {
export * from '~ng2-charts/ng2-charts';
}

File diff suppressed because it is too large Load Diff