[pull] master from DefinitelyTyped:master

types/rangy/index.d.ts

@@ -1,68 +1 @@
-interface RangyRange extends Range {
-    setStartAndEnd(startNode: Node, startOffset: number, endNode?: Node, endOffset?: number): any;
-    setStartAndEnd(startNode: Node, startOffset: number, endOffset: number): any;
-    canSurroundContents(): boolean;
-    isValid(): boolean;
-    toHtml(): string;
-    compareNode(node: Node): any;
-    intersectsOrTouchesRange(range: RangyRange): boolean;
-    intersectsRange(range: RangyRange): boolean;
-    intersection(range: RangyRange): RangyRange;
-    union(range: RangyRange): RangyRange;
-    containsNode(node: Node, partial: boolean): boolean;
-    containsNodeContents(node: Node): boolean;
-    containsNodeText(node: Node): boolean;
-    containsRange(range: RangyRange): boolean;
-    splitBoundaries(): any;
-    normalizeBoundaries(): any;
-    collapseToPoint(node: Node, offset: number): any;
-    collapseBefore(node: Node): any;
-    collapseAfter(node: Node): any;
-    getNodes(nodeTypes?: any[], filter?: (node: Node) => boolean): Node[];
-    getBookmark(containerNode?: Node): { start: number; end: number };
-    moveToBookmark(bookmark: Object): any;
-    getDocument(): Document;
-    inspect(): string;
-    equals(range: RangyRange): boolean;
-    refresh(): any;
-    select(): any;
-    toCharacterRange(containerNode: Node, opts?: any): { start: number; end: number };
-}
-
-interface RangySelection extends Selection {
-    nativeSelection: Selection;
-    isBackwards(): boolean;
-    refresh(checkForChanges?: boolean): any;
-    toHtml(): string;
-    getAllRanges(): RangyRange[];
-    getRangeAt(idx: number): RangyRange;
-    getNativeTextRange(): any;
-    setSingleRange(range: RangyRange): any;
-    setRanges(ranges: RangyRange[]): any;
-    getBookmark(containerNode: Node): any;
-    moveToBookmark(bookmark: Object): any;
-    saveRanges(): Object;
-    restoreRanges(saved: Object): any;
-    saveCharacterRanges(containerNode: Node, opts?: any): Object;
-    restoreCharacterRanges(containerNode: Node, characterRanges: Object, opts?: any): any;
-    detach(): any;
-    inspect(): string;
-    move(units: string, count: number, opts?: any): number;
-}
-
-interface RangyStatic {
-    createNativeRange(doc?: Document | Window | HTMLIFrameElement): Range;
-    createRange(doc?: Document | Window | HTMLIFrameElement): RangyRange;
-    createRangyRange(doc?: Document | Window | HTMLIFrameElement): RangyRange;
-    getNativeSelection(win?: Window): Selection;
-    getSelection(doc?: Document | Window | HTMLIFrameElement): RangySelection;
-    addInitListener(listener: (rangy: RangyStatic) => void): any;
-    shim(): any;
-    createMissingNativeApi(): any;
-    initialized: boolean;
-    supported: boolean;
-}
-declare module "rangy" {
-    export = rangy;
-}
-declare var rangy: RangyStatic;
+export {};

types/rangy/lib/rangy-classapplier.d.ts

@@ -0,0 +1,39 @@
+import "./rangy-core";
+
+declare global {
+    namespace rangy {
+        interface RangyClassApplierOptions {
+            elementTagName?: string;
+            elementProperties?: { [key: string]: string };
+            elementAttributes?: { [key: string]: string };
+            ignoreWhiteSpace?: boolean;
+            applyToEditableOnly?: boolean;
+            tagNames?: string[] | string;
+            normalize?: boolean;
+            onElementCreate?: ((element: Element, classApplier: RangyClassApplier) => any) | undefined;
+            useExistingElements?: boolean;
+        }
+
+        interface RangyClassApplier {
+            applyToSelection(win?: Window): void;
+            undoToSelection(win?: Window): void;
+            isAppliedToSelection(win?: Window): boolean;
+            toggleSelection(win?: Window): void;
+            applyToRange(range: RangyRange): void;
+            undoToRange(range: RangyRange): void;
+            isAppliedToRange(range: RangyRange): boolean;
+            toggleRange(range: RangyRange): void;
+            detach(doc?: Document | Window | HTMLIFrameElement): void;
+            className: string;
+            cssClass: string;
+        }
+
+        function createClassApplier(
+            className: string,
+            options?: RangyClassApplierOptions,
+            tagNames?: string[] | string,
+        ): RangyClassApplier;
+    }
+}
+
+export = rangy;

types/rangy/lib/rangy-core.d.ts

@@ -0,0 +1,152 @@
+export const version: string;
+
+export interface RangyRange extends Range {
+    startContainer: Node;
+    startOffset: number;
+    endContainer: Node;
+    endOffset: number;
+    commonAncestorContainer: Node;
+    collapsed: boolean;
+    setStart(node: Node, offset: number): void;
+    setStartBefore(node: Node): void;
+    setStartAfter(node: Node): void;
+    setEnd(node: Node, offset: number): void;
+    setEndBefore(node: Node): void;
+    setEndAfter(node: Node): void;
+    setStartAndEnd(startNode: Node, startOffset: number, endNode?: Node, endOffset?: number): any;
+    selectNode(node: Node): any;
+    selectNodeContents(node: Node): any;
+    collapse(toStart?: boolean): void;
+    compareBoundaryPoints(comparisonType: number, range: RangyRange): number;
+    insertNode(node: Node): any;
+    cloneContents(): DocumentFragment;
+    extractContents(): DocumentFragment;
+    deleteContents(): void;
+    canSurroundContents(): boolean;
+    surroundContents(node: Node): boolean;
+    cloneRange(): RangyRange;
+    isValid(): boolean;
+    toString(): string;
+    toHtml(): string;
+    compareNode(node: Node): NodeType;
+    comparePoint(node: Node, offset: number): -1 | 0 | 1;
+    intersectsOrTouchesRange(range: RangyRange): boolean;
+    intersectsRange(range: RangyRange): boolean;
+    intersectsNode(node: Node, touchingIsIntersecting?: boolean): boolean;
+    intersection(range: RangyRange): RangyRange | null;
+    union(range: RangyRange): RangyRange | null;
+    isPointInRange(node: Node, offset: number): boolean;
+    createContextualFragment(fragment: string): DocumentFragment;
+    containsNode(node: Node, partial: boolean): boolean;
+    containsNodeContents(node: Node): boolean;
+    containsNodeText(node: Node): boolean;
+    containsRange(range: RangyRange): boolean;
+    splitBoundaries(): any;
+    normalizeBoundaries(): any;
+    collapseToPoint(node: Node, offset: number): any;
+    collapseBefore(node: Node): any;
+    collapseAfter(node: Node): any;
+    getNodes(nodeTypes?: any[], filter?: (node: Node) => boolean): Node[];
+    getBookmark(containerNode?: Node): { start: number; end: number };
+    moveToBookmark(bookmark: Object): any;
+    getDocument(): Document;
+    inspect(): string;
+    equals(range: RangyRange): boolean;
+    refresh(): any;
+    select(): any;
+    detach(): void;
+}
+
+export interface RangySelection extends Selection {
+    nativeSelection: Selection;
+    rangeCount: number;
+    isCollapsed: boolean;
+    anchorNode: Node | null;
+    anchorOffset: number;
+    focusNode: Node | null;
+    focusOffset: number;
+    addRange(range: RangyRange, direction?: Direction | boolean): void;
+    getRangeAt(index: number): RangyRange;
+    isBackwards(): boolean;
+    removeAllRanges(): void;
+    removeRange(range: RangyRange): void;
+    refresh(checkForChanges?: boolean): any;
+    collapse(node: Node, offset: number): void;
+    collapseToStart(): void;
+    collapseToEnd(): void;
+    selectAllChildren(node: Node): void;
+    deleteFromDocument(): void;
+    toString(): string;
+    toHtml(): string;
+    getAllRanges(): RangyRange[];
+    getNativeTextRange(): Range;
+    getSingleRange(range: RangyRange, direction: Direction): any;
+    setRanges(ranges: RangyRange[]): any;
+    containsNode(node: Node, partial: boolean): boolean;
+    getBookmark(containerNode: Node): any;
+    moveToBookmark(bookmark: Object): any;
+    saveRanges(): Object;
+    restoreRanges(saved: Object): any;
+    detach(): any;
+    inspect(): string;
+}
+
+export type Direction = "forward" | "forwards" | "backward" | "backwards" | boolean;
+export type NodeType = "NODE_BEFORE" | "NODE_AFTER" | "NODE_BEFORE_AND_AFTER" | "NODE_INSIDE";
+
+export interface CookieOptions {
+    expires?: Date;
+    path?: string;
+    domain?: string;
+    secure?: boolean;
+}
+
+export interface DomPosition {
+    node: Node;
+    offset: number;
+}
+export type RangyStatic = typeof import("rangy");
+export function addInitListener(listener: (rangy: RangyStatic) => void): void;
+export function createMissingNativeApi(): void;
+export function shim(): void;
+export function createNativeRange(doc?: Document | Window | HTMLIFrameElement): Range;
+export function createRange(doc?: Document | Window | HTMLIFrameElement): RangyRange;
+export function createRangyRange(doc?: Document | Window | HTMLIFrameElement): RangyRange;
+export function getNativeSelection(win?: Window): Selection;
+export function getSelection(win?: Window): RangySelection;
+export var initialized: boolean;
+export var supported: boolean;
+export var config: {
+    alertOnFail: boolean;
+    alertOnWarn: boolean;
+    checkSelectionRanges: boolean;
+    preferTextRange: boolean;
+    autoInitialize: boolean;
+};
+export var dom: any;
+export var features: {
+    collapsedNonEditableSelectionsSupported: boolean;
+    implementsControlRange: boolean;
+    implementsDomRange: boolean;
+    implementsTextRange: boolean;
+    selectionHasAnchorAndFocus: boolean;
+    selectionHasExtend: boolean;
+    selectionHasRangeCount: boolean;
+    selectionSupportsMultipleRanges: boolean;
+    crashyTextNodes: boolean;
+    implementsDocSelection: boolean;
+    implementsWinGetSelection: boolean;
+};
+
+export var util: {
+    isHostObject(obj: any, prop: string): boolean;
+    isHostMethod(obj: any, method: string): boolean;
+    isHostProperty(obj: any, prop: string): boolean;
+    areHostObjects(obj: any, props: string[]): boolean;
+    areHostMethods(obj: any, methods: string[]): boolean;
+    areHostProperties(obj: any, props: string[]): boolean;
+    toArray(arrayLike: any): any[];
+};
+export function init(): void;
+
+export as namespace rangy;

types/rangy/lib/rangy-highlighter.d.ts

@@ -0,0 +1,49 @@
+import "./rangy-classapplier";
+import "./rangy-core";
+
+declare global {
+    namespace rangy {
+        interface RangyHighlighter {
+            addClassApplier(classApplier: RangyClassApplier, options?: RangyHighlighterAddClassOptions): void;
+            highlightSelection(className: string, options?: RangyHighlightOptions): string[];
+            unhighlightSelection(selection?: RangySelection): boolean;
+            removeAllHighlights(): void;
+            serialize(highlights?: RangyHighlight[]): string;
+            deserialize(serialized: string): RangyHighlight[];
+            getHighlightForElement(el: Element): RangyHighlight | null;
+        }
+
+        interface RangyHighlighterAddClassOptions {
+            priority?: number;
+            exclusive?: boolean;
+        }
+
+        interface RangyHighlightOptions {
+            selection?: RangySelection;
+            exclusive?: boolean;
+            containerElementId?: string;
+        }
+
+        interface RangyHighlight {
+            id: string;
+            classApplier: RangyClassApplier;
+            characterRange: {
+                start: number;
+                end: number;
+                containerElement: Node;
+            };
+            containsElement(el: Node): boolean;
+            containsRange(range: RangyRange): boolean;
+            intersectsRange(range: RangyRange): boolean;
+            isCharacterRange(containerElement: Node): boolean;
+            getRange(containerElement?: Node): RangyRange;
+        }
+
+        function createHighlighter(
+            doc?: Document | Window | HTMLIFrameElement,
+            type?: "textContent" | "textRange",
+        ): RangyHighlighter;
+    }
+}
+
+export = rangy;

types/rangy/lib/rangy-selectionsaverestore.d.ts

@@ -0,0 +1,15 @@
+import "./rangy-core";
+
+declare global {
+    namespace rangy {
+        function saveSelection(win?: Window): object | null;
+        function restoreSelection(savedSelection: object, preserveDirection?: boolean): boolean;
+        function saveRange(range: Range): object;
+        function restoreRange(savedRange: object, normalize?: boolean): Range;
+        function saveRanges(ranges: Range[], direction?: Direction | boolean): object[];
+        function restoreRanges(savedRanges: object[]): Range[];
+        function removeMarkers(savedSelection: object): void;
+    }
+}
+
+export = rangy;

types/rangy/lib/rangy-serializer.d.ts

@@ -0,0 +1,18 @@
+import "./rangy-core";
+
+declare global {
+    namespace rangy {
+        function serializeSelection(selection?: RangySelection, omitChecksum?: boolean, root?: Node): string;
+        function canDeserializeSelection(serializedSelection: string, root?: Node, win?: Window): boolean;
+        function deserializeSelection(serializedSelection: string, root?: Node, win?: Window): RangySelection;
+        function serializeRange(range: RangyRange, omitChecksum?: boolean, root?: Node): string;
+        function canDeserializeRange(serializedRange: string, root?: Node, doc?: Document): boolean;
+        function deserializeRange(serializedRange: string, root?: Node, doc?: Document): RangyRange;
+        function serializePosition(node: Node, offset: number, root?: Node): string;
+        function deserializePosition(serializedPosition: string, root?: Node, doc?: Document): DomPosition;
+        function saveSelectionCookie(win?: Window, props?: CookieOptions): void;
+        function restoreSelectionFromCookie(win?: Window): boolean;
+    }
+}
+
+export = rangy;

types/rangy/lib/rangy-textrange.d.ts

@@ -0,0 +1,48 @@
+import "./rangy-core";
+
+declare global {
+    namespace rangy {
+        interface RangyWordOptions {
+            includeTrailingSpace?: boolean;
+            wordRegex?: RegExp;
+        }
+
+        interface RangyCharacterOptions {
+            includeBlockContentTrailingSpace?: boolean;
+            includeSpaceBeforeBr?: boolean;
+            includePreLineTrailingSpace?: boolean;
+            ignoreCharacters?: string;
+        }
+
+        interface RangyTextOptions extends RangyWordOptions, RangyCharacterOptions {}
+
+        interface RangyFindTextOptions {
+            caseSensitive?: boolean;
+            withinRange?: RangyRange;
+            wholeWordsOnly?: boolean;
+            wrap?: boolean;
+            direction?: "forward" | "backward";
+            wordOptions?: RangyWordOptions;
+            characterOptions?: RangyCharacterOptions;
+        }
+
+        interface RangyTextExpandOptions extends RangyTextOptions {
+            trim?: boolean;
+            trimStart?: boolean;
+            trimEnd?: boolean;
+        }
+
+        interface RangyTextRange {
+            moveStart(unit: string, count: number, options?: RangyTextOptions): number;
+            moveEnd(unit: string, count: number, options?: RangyTextOptions): number;
+            move(unit: string, count: number, options?: RangyTextOptions): number;
+            expand(unit: string, options?: RangyTextExpandOptions): boolean;
+            text(): string;
+            selectCharacters(containerNode: Node, startIndex: number, endIndex: number): void;
+            toCharacterRange(containerNode: Node, options?: RangyTextOptions): { start: number; end: number };
+            findText(searchTerm: string | RegExp, options?: RangyFindTextOptions): boolean;
+        }
+    }
+}
+
+export = rangy;