Merge pull request #6 from Volicon/f/export-d-ts

F/export d ts

Author: Vlad Balin

dist/collection/add.d.ts

@@ -0,0 +1,5 @@
+import { CollectionTransaction, CollectionOptions, CollectionCore } from './commons';
+export interface AddOptions extends CollectionOptions {
+    at?: number;
+}
+export declare function addTransaction(collection: CollectionCore, items: any, options: AddOptions, merge?: boolean): CollectionTransaction;

dist/collection/commons.d.ts

@@ -0,0 +1,42 @@
+import { Record } from '../record';
+import { Owner, Transaction, TransactionOptions, Transactional } from '../transactions';
+import { eventsApi } from '../object-plus';
+export interface CollectionCore extends Transactional, Owner {
+    _byId: IdIndex;
+    models: Record[];
+    model: typeof Record;
+    idAttribute: string;
+    _comparator: Comparator;
+    get(objOrId: string | Record | Object): Record;
+    _itemEvents?: eventsApi.EventMap;
+    _shared: number;
+    _aggregationError: Record[];
+    _log(level: string, text: string, value: any): any;
+}
+export declare type Elements = (Object | Record)[];
+export interface CollectionOptions extends TransactionOptions {
+    sort?: boolean;
+}
+export declare type Comparator = (a: Record, b: Record) => number;
+export declare function dispose(collection: CollectionCore): Record[];
+export declare function convertAndAquire(collection: CollectionCore, attrs: {} | Record, options: any): Record;
+export declare function free(owner: CollectionCore, child: Record): void;
+export declare function freeAll(collection: CollectionCore, children: Record[]): Record[];
+export declare function sortElements(collection: CollectionCore, options: CollectionOptions): boolean;
+export interface IdIndex {
+    [id: string]: Record;
+}
+export declare function addIndex(index: IdIndex, model: Record): void;
+export declare function removeIndex(index: IdIndex, model: Record): void;
+export declare function updateIndex(index: IdIndex, model: Record): void;
+export declare class CollectionTransaction implements Transaction {
+    object: CollectionCore;
+    isRoot: boolean;
+    added: Record[];
+    removed: Record[];
+    nested: Transaction[];
+    sorted: boolean;
+    constructor(object: CollectionCore, isRoot: boolean, added: Record[], removed: Record[], nested: Transaction[], sorted: boolean);
+    commit(initiator?: Transactional): void;
+}
+export declare function logAggregationError(collection: CollectionCore): void;

dist/collection/index.d.ts

@@ -0,0 +1,68 @@
+import { EventMap, EventsDefinition } from '../object-plus';
+import { Transactional, CloneOptions, TransactionOptions, TransactionalDefinition } from '../transactions';
+import { Record, AggregatedType } from '../record';
+import { IdIndex, CollectionCore, CollectionTransaction } from './commons';
+export declare type GenericComparator = string | ((x: Record) => number) | ((a: Record, b: Record) => number);
+export interface CollectionOptions extends TransactionOptions {
+    comparator?: GenericComparator;
+    model?: typeof Record;
+}
+export interface CollectionDefinition extends TransactionalDefinition {
+    model?: Record;
+    itemEvents?: EventsDefinition;
+    _itemEvents?: EventMap;
+}
+export declare class Collection extends Transactional implements CollectionCore {
+    _shared: number;
+    _aggregationError: Record[];
+    static Subset: typeof Collection;
+    static Refs: typeof Collection;
+    static _SubsetOf: typeof Collection;
+    createSubset(models: any, options: any): any;
+    static predefine(): any;
+    static define(protoProps?: CollectionDefinition, staticProps?: any): any;
+    static subsetOf: (collectionReference: any) => any;
+    _itemEvents: EventMap;
+    models: Record[];
+    readonly __inner_state__: Record[];
+    _byId: IdIndex;
+    comparator: GenericComparator;
+    getStore(): Transactional;
+    _store: Transactional;
+    _comparator: (a: Record, b: Record) => number;
+    _onChildrenChange(record: Record, options?: TransactionOptions, initiator?: Transactional): void;
+    get(objOrId: string | Record | Object): Record;
+    each(iteratee: (val: Record, key: number) => void, context?: any): void;
+    map<T>(iteratee: (val: Record, key: number) => T, context?: any): T[];
+    _validateNested(errors: {}): number;
+    model: typeof Record;
+    idAttribute: string;
+    constructor(records?: (Record | {})[], options?: CollectionOptions, shared?: number);
+    initialize(): void;
+    readonly length: number;
+    first(): Record;
+    last(): Record;
+    at(a_index: number): Record;
+    clone(options?: CloneOptions): this;
+    toJSON(): Object[];
+    set(elements?: ElementsArg, options?: TransactionOptions): this;
+    dispose(): void;
+    reset(a_elements?: ElementsArg, options?: TransactionOptions): Record[];
+    add(a_elements: ElementsArg, options?: TransactionOptions): Record[];
+    remove(recordsOrIds: any, options?: TransactionOptions): Record[] | Record;
+    _createTransaction(a_elements: ElementsArg, options?: TransactionOptions): CollectionTransaction;
+    static _attribute: typeof AggregatedType;
+    pluck(key: string): any[];
+    sort(options?: TransactionOptions): this;
+    push(model: any, options: any): Record[];
+    pop(options: any): Record;
+    unshift(model: any, options: any): Record[];
+    shift(options?: CollectionOptions): Record;
+    slice(): Record[];
+    indexOf(modelOrId: any): number;
+    modelId(attrs: {}): any;
+    toggle(model: Record, a_next?: boolean): boolean;
+    _log(level: string, text: string, value: any): void;
+    getClassName(): string;
+}
+export declare type ElementsArg = Object | Record | Object[] | Record[];

dist/collection/remove.d.ts

@@ -0,0 +1,5 @@
+import { Record } from '../record';
+import { CollectionCore } from './commons';
+import { TransactionOptions } from '../transactions';
+export declare function removeOne(collection: CollectionCore, el: Record | {} | string, options: TransactionOptions): Record;
+export declare function removeMany(collection: CollectionCore, toRemove: any[], options: any): any[];

dist/collection/set.d.ts

@@ -0,0 +1,3 @@
+import { CollectionTransaction, CollectionOptions, CollectionCore, Elements } from './commons';
+export declare function emptySetTransaction(collection: CollectionCore, items: Elements, options: CollectionOptions, silent?: boolean): CollectionTransaction;
+export declare function setTransaction(collection: any, items: any, options: any): CollectionTransaction;

dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './object-plus';
+export * from './collection';
+export * from './relations';
+export * from './record';
+export declare const on: any, off: any, trigger: any, once: any, listenTo: any, stopListening: any, listenToOnce: any;
+import { Record as Model } from './record';
+import { Mixable as Class } from './object-plus/';
+export { Model, Class };
+import { ChainableAttributeSpec } from './record';
+export declare function value(x: any): ChainableAttributeSpec;
+export declare function transaction<F extends Function>(method: F): F;