flip/DefinitelyTyped
1
0
Fork 0
mirror of https://github.com/FlipsideCrypto/DefinitelyTyped.git synced 2026-02-06 10:56:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

mobservable provides its own types (#14776)

Browse Source
This commit is contained in:
Andy 2017-03-10 07:56:11 -08:00 committed by GitHub
parent 51b64c3c15
commit f0b18c41f7
6 changed files with 187 additions and 266 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

182
mendixmodelsdk/index.d.ts vendored
View File

@ -207,8 +207,188 @@
limitations under the License.
*/
// Outdated mobservable typings.
// TODO: Use the types bundled with mobservable. Or use mobx.
interface _IMobservableStatic {
/**
* Turns an object, array or function into a reactive structure.
* @param value the value which should become observable.
*/
makeReactive: IMakeReactive;
/**
* Extends an object with reactive capabilities.
* @param target the object to which reactive properties should be added
* @param properties the properties that should be added and made reactive
* @returns targer
*/
extendReactive(target: Object, properties: Object):Object;
/**
* Returns true if the provided value is reactive.
* @param value object, function or array
* @param propertyName if propertyName is specified, checkes whether value.propertyName is reactive.
*/
isReactive(value: any, propertyName?:string): boolean;
/**
* Can be used in combination with makeReactive / extendReactive.
* Enforces that a reference to 'value' is stored as property,
* but that 'value' itself is not turned into something reactive.
* Future assignments to the same property will inherit this behavior.
* @param value initial value of the reactive property that is being defined.
*/
asReference<T>(value: any):{value:T};
/**
* ES6 / Typescript decorator which can to make class properties and getter functions reactive.
*/
observable(target: Object, key: string):any; // decorator / annotation
/**
* Creates a reactive view and keeps it alive, so that the view is always
* updated if one of the dependencies changes, even when the view is not further used by something else.
* @param func The reactive view
* @param scope (optional)
* @returns disposer function, which can be used to stop the view from being updated in the future.
*/
observe(func: Mobservable.Lambda, scope?: any): Mobservable.Lambda;
/**
* Deprecated, use mobservable.observe instead.
*/
sideEffect(func: Mobservable.Lambda, scope?: any): Mobservable.Lambda;
/**
* Similar to 'observer', observes the given predicate until it returns true.
* Once it returns true, the 'effect' function is invoked an the observation is cancelled.
* @param predicate
* @param effect
* @param scope (optional)
* @returns disposer function to prematurely end the observer.
*/
observeUntil(predicate: ()=>boolean, effect: Mobservable.Lambda, scope?: any): Mobservable.Lambda;
/**
* During a transaction no views are updated until the end of the transaction.
* The transaction will be run synchronously nonetheless.
* @param action a function that updates some reactive state
* @returns any value that was returned by the 'action' parameter.
*/
transaction<T>(action: ()=>T): T;
/**
* Converts a reactive structure into a non-reactive structure.
* Basically a deep-clone.
*/
toJSON<T>(value: T): T;
/**
* Sets the reporting level Defaults to 1. Use 0 for production or 2 for increased verbosity.
*/
logLevel: number; // 0 = production, 1 = development, 2 = debugging
extras: {
getDependencyTree(thing:any, property?:string): Mobservable.IDependencyTree;
getObserverTree(thing:any, property?:string): Mobservable.IObserverTree;
trackTransitions(extensive?:boolean, onReport?:(lines:Mobservable.ITransitionEvent) => void) : Mobservable.Lambda;
}
}
interface IMakeReactive {
<T>(value: T[], opts?: Mobservable.IMakeReactiveOptions): Mobservable.IObservableArray<T>;
<T>(value: ()=>T, opts?: Mobservable.IMakeReactiveOptions): Mobservable.IObservableValue<T>;
<T extends string|number|boolean|Date|RegExp|Function|void>(value: T, opts?: Mobservable.IMakeReactiveOptions): Mobservable.IObservableValue<T>;
<T extends Object>(value: Object, opts?: Mobservable.IMakeReactiveOptions): T;
}
interface IMobservableStatic extends _IMobservableStatic, IMakeReactive {
}
declare namespace Mobservable {
interface IMakeReactiveOptions {
as?: string /* "auto" | "reference" | TODO: see #8 "structure" */
scope?: Object,
context?: Object,
recurse?: boolean;
name?: string;
// protected: boolean TODO: see #9
}
export interface IContextInfoStruct {
object: Object;
name: string;
}
export type IContextInfo = IContextInfoStruct | string;
interface Lambda {
(): void;
name?: string;
}
interface IObservable {
observe(callback: (...args: any[])=>void, fireImmediately?: boolean): Lambda;
}
interface IObservableValue<T> extends IObservable {
(): T;
(value: T):void;
observe(callback: (newValue: T, oldValue: T)=>void, fireImmediately?: boolean): Lambda;
}
interface IObservableArray<T> extends IObservable, Array<T> {
spliceWithArray(index: number, deleteCount?: number, newItems?: T[]): T[];
observe(listener: (changeData: IArrayChange<T>|IArraySplice<T>)=>void, fireImmediately?: boolean): Lambda;
clear(): T[];
replace(newItems: T[]): T[];
find(predicate: (item: T,index: number,array: IObservableArray<T>)=>boolean,thisArg?: any,fromIndex?: number): T;
remove(value: T): boolean;
}
interface IArrayChange<T> {
type: string; // Always: 'update'
object: IObservableArray<T>;
index: number;
oldValue: T;
}
interface IArraySplice<T> {
type: string; // Always: 'splice'
object: IObservableArray<T>;
index: number;
removed: T[];
addedCount: number;
}
interface IDependencyTree {
id: number;
name: string;
context: any;
dependencies?: IDependencyTree[];
}
interface IObserverTree {
id: number;
name: string;
context: any;
observers?: IObserverTree[];
listeners?: number; // amount of functions manually attached using an .observe method
}
interface ITransitionEvent {
id: number;
name: string;
context: Object;
state: string;
changed: boolean;
newValue: string;
}
}
/// <reference types="mobservable" />
declare module "mendixmodelsdk" {
namespace sdk {
namespace internal {

178
mobservable/index.d.ts vendored
View File

@ -1,178 +0,0 @@
// Type definitions for mobservable 0.6
// Project: https://mweststrate.github.io/mobservable
// Definitions by: Michel Weststrate <https://github.com/mweststrate/>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
declare namespace Mobservable {
interface Static extends MakeReactive {
/**
* Turns an object, array or function into a reactive structure.
* @param value the value which should become observable.
*/
makeReactive: MakeReactive;
/**
* Extends an object with reactive capabilities.
* @param target the object to which reactive properties should be added
* @param properties the properties that should be added and made reactive
* @returns targer
*/
extendReactive(target: Object, properties: Object): Object;
/**
* Returns true if the provided value is reactive.
* @param value object, function or array
* @param propertyName if propertyName is specified, checkes whether value.propertyName is reactive.
*/
isReactive(value: any, propertyName?: string): boolean;
/**
* Can be used in combination with makeReactive / extendReactive.
* Enforces that a reference to 'value' is stored as property,
* but that 'value' itself is not turned into something reactive.
* Future assignments to the same property will inherit this behavior.
* @param value initial value of the reactive property that is being defined.
*/
asReference<T>(value: any): {value: T};
/**
* ES6 / Typescript decorator which can to make class properties and getter functions reactive.
*/
observable(target: Object, key: string): any; // decorator / annotation
/**
* Creates a reactive view and keeps it alive, so that the view is always
* updated if one of the dependencies changes, even when the view is not further used by something else.
* @param func The reactive view
* @param scope (optional)
* @returns disposer function, which can be used to stop the view from being updated in the future.
*/
observe(func: Mobservable.Lambda, scope?: any): Mobservable.Lambda;
/**
* Deprecated, use mobservable.observe instead.
*/
sideEffect(func: Mobservable.Lambda, scope?: any): Mobservable.Lambda;
/**
* Similar to 'observer', observes the given predicate until it returns true.
* Once it returns true, the 'effect' function is invoked an the observation is cancelled.
* @param predicate
* @param effect
* @param scope (optional)
* @returns disposer function to prematurely end the observer.
*/
observeUntil(predicate: () => boolean, effect: Mobservable.Lambda, scope?: any): Mobservable.Lambda;
/**
* During a transaction no views are updated until the end of the transaction.
* The transaction will be run synchronously nonetheless.
* @param action a function that updates some reactive state
* @returns any value that was returned by the 'action' parameter.
*/
transaction<T>(action: () => T): T;
/**
* Converts a reactive structure into a non-reactive structure.
* Basically a deep-clone.
*/
toJSON<T>(value: T): T;
/**
* Sets the reporting level Defaults to 1. Use 0 for production or 2 for increased verbosity.
*/
logLevel: number; // 0 = production, 1 = development, 2 = debugging
extras: {
getDependencyTree(thing: any, property?: string): Mobservable.DependencyTree;
getObserverTree(thing: any, property?: string): Mobservable.ObserverTree;
trackTransitions(extensive?: boolean, onReport?: (lines: Mobservable.TransitionEvent) => void): Mobservable.Lambda;
};
}
interface MakeReactive {
<T>(value: T[], opts?: Mobservable.MakeReactiveOptions): Mobservable.ObservableArray<T>;
<T>(value: () => T, opts?: Mobservable.MakeReactiveOptions): Mobservable.ObservableValue<T>;
<T extends string|number|boolean|Date|RegExp|Function|undefined>(value: T, opts?: Mobservable.MakeReactiveOptions): Mobservable.ObservableValue<T>;
<T extends Object>(value: Object, opts?: Mobservable.MakeReactiveOptions): T;
}
interface MakeReactiveOptions {
as?: string; /* "auto" | "reference" | TODO: see #8 "structure" */
scope?: Object;
context?: Object;
recurse?: boolean;
name?: string;
// protected: boolean TODO: see #9
}
type ContextInfo = { object: Object; name: string } | string;
interface Lambda {
(): void;
name?: string;
}
interface Observable {
observe(callback: (...args: any[]) => void, fireImmediately?: boolean): Lambda;
}
interface ObservableValue<T> extends Observable {
(): T;
(value: T): void;
observe(callback: (newValue: T, oldValue: T) => void, fireImmediately?: boolean): Lambda;
}
interface ObservableArray<T> extends Observable, Array<T> {
spliceWithArray(index: number, deleteCount?: number, newItems?: T[]): T[];
observe(listener: (changeData: ArrayChange<T>|ArraySplice<T>) => void, fireImmediately?: boolean): Lambda;
clear(): T[];
replace(newItems: T[]): T[];
find(predicate: (item: T, index: number, array: ObservableArray<T>) => boolean, thisArg?: any, fromIndex?: number): T;
remove(value: T): boolean;
}
interface ArrayChange<T> {
type: string; // Always: 'update'
object: ObservableArray<T>;
index: number;
oldValue: T;
}
interface ArraySplice<T> {
type: string; // Always: 'splice'
object: ObservableArray<T>;
index: number;
removed: T[];
addedCount: number;
}
interface DependencyTree {
id: number;
name: string;
context: any;
dependencies?: DependencyTree[];
}
interface ObserverTree {
id: number;
name: string;
context: any;
observers?: ObserverTree[];
listeners?: number; // amount of functions manually attached using an .observe method
}
interface TransitionEvent {
id: number;
name: string;
context: Object;
state: string;
changed: boolean;
newValue: string;
}
}
declare const Mobservable: Mobservable.Static;
export = Mobservable;

56
mobservable/mobservable-tests.ts
View File

@ -1,56 +0,0 @@
import mobservable = require('mobservable');
import {observable} from "mobservable";
var v = mobservable(3);
v.observe(() => {});
var a = mobservable([1, 2, 3]);
class Order {
@observable price: number = 3;
@observable amount: number = 2;
@observable orders: string[] = [];
@observable get total() {
return this.amount * this.price * (1 + this.orders.length);
}
}
export function testObservable() {
var a = mobservable(3);
var b = mobservable(() => a() * 2);
}
export function testAnnotations() {
var order1totals: number[] = [];
var order1 = new Order();
var order2 = new Order();
var disposer = mobservable.observe(() => {
order1totals.push(order1.total);
});
order2.price = 4;
order1.amount = 1;
order2.orders.push('bla');
order1.orders.splice(0, 0, 'boe', 'hoi');
disposer();
order1.orders.pop();
};
export function testTyping() {
var ar: mobservable.ObservableArray<number> = mobservable.makeReactive([1, 2]);
ar.observe((d: mobservable.ArrayChange<number> | mobservable.ArraySplice<number>) => {
console.log(d.type);
});
var ar2: mobservable.ObservableArray<number> = mobservable([1, 2]);
ar2.observe((d: mobservable.ArrayChange<number> | mobservable.ArraySplice<number>) => {
console.log(d.type);
});
var x: mobservable.ObservableValue<number> = mobservable(3);
}

25
mobservable/tsconfig.json
View File

@ -1,25 +0,0 @@
{
"compilerOptions": {
"module": "commonjs",
"target": "es6",
"lib": [
"es6",
"dom"
],
"noImplicitAny": true,
"noImplicitThis": true,
"strictNullChecks": false,
"baseUrl": "../",
"experimentalDecorators": true,
"typeRoots": [
"../"
],
"types": [],
"noEmit": true,
"forceConsistentCasingInFileNames": true
},
"files": [
"index.d.ts",
"mobservable-tests.ts"
]
}

6
mobservable/tslint.json
View File

@ -1,6 +0,0 @@
{
"extends": "../tslint.json",
"rules": {
"forbidden-types": false
}
}

6
notNeededPackages.json
View File

@ -329,6 +329,12 @@
"typingsPackageName": "fine-uploader",
"sourceRepoURL": "http://fineuploader.com/",
"asOfVersion": "5.14.0"
},
{
"libraryName": "mobservable",
"typingsPackageName": "mobservable",
"sourceRepoURL": "github.com/mweststrate/mobservable",
"asOfVersion": "1.2.5"
}
]
}