Skip to content

Commit 69ff06a

Browse files
kyusungparksandersn
kyusungpark
and
sandersn
authored
🤖 Merge PR DefinitelyTyped#72084 Add rangy types by @kyusungpark
Co-authored-by: Nathan Shively-Sanders <[email protected]>
1 parent 3b8a587 commit 69ff06a

11 files changed

+375
-165
lines changed

‎types/rangy/index.d.ts‎

Lines changed: 1 addition & 68 deletions
Original file line numberDiff line numberDiff line change
@@ -1,68 +1 @@
1-
interface RangyRange extends Range {
2-
setStartAndEnd(startNode: Node, startOffset: number, endNode?: Node, endOffset?: number): any;
3-
setStartAndEnd(startNode: Node, startOffset: number, endOffset: number): any;
4-
canSurroundContents(): boolean;
5-
isValid(): boolean;
6-
toHtml(): string;
7-
compareNode(node: Node): any;
8-
intersectsOrTouchesRange(range: RangyRange): boolean;
9-
intersectsRange(range: RangyRange): boolean;
10-
intersection(range: RangyRange): RangyRange;
11-
union(range: RangyRange): RangyRange;
12-
containsNode(node: Node, partial: boolean): boolean;
13-
containsNodeContents(node: Node): boolean;
14-
containsNodeText(node: Node): boolean;
15-
containsRange(range: RangyRange): boolean;
16-
splitBoundaries(): any;
17-
normalizeBoundaries(): any;
18-
collapseToPoint(node: Node, offset: number): any;
19-
collapseBefore(node: Node): any;
20-
collapseAfter(node: Node): any;
21-
getNodes(nodeTypes?: any[], filter?: (node: Node) => boolean): Node[];
22-
getBookmark(containerNode?: Node): { start: number; end: number };
23-
moveToBookmark(bookmark: Object): any;
24-
getDocument(): Document;
25-
inspect(): string;
26-
equals(range: RangyRange): boolean;
27-
refresh(): any;
28-
select(): any;
29-
toCharacterRange(containerNode: Node, opts?: any): { start: number; end: number };
30-
}
31-
32-
interface RangySelection extends Selection {
33-
nativeSelection: Selection;
34-
isBackwards(): boolean;
35-
refresh(checkForChanges?: boolean): any;
36-
toHtml(): string;
37-
getAllRanges(): RangyRange[];
38-
getRangeAt(idx: number): RangyRange;
39-
getNativeTextRange(): any;
40-
setSingleRange(range: RangyRange): any;
41-
setRanges(ranges: RangyRange[]): any;
42-
getBookmark(containerNode: Node): any;
43-
moveToBookmark(bookmark: Object): any;
44-
saveRanges(): Object;
45-
restoreRanges(saved: Object): any;
46-
saveCharacterRanges(containerNode: Node, opts?: any): Object;
47-
restoreCharacterRanges(containerNode: Node, characterRanges: Object, opts?: any): any;
48-
detach(): any;
49-
inspect(): string;
50-
move(units: string, count: number, opts?: any): number;
51-
}
52-
53-
interface RangyStatic {
54-
createNativeRange(doc?: Document | Window | HTMLIFrameElement): Range;
55-
createRange(doc?: Document | Window | HTMLIFrameElement): RangyRange;
56-
createRangyRange(doc?: Document | Window | HTMLIFrameElement): RangyRange;
57-
getNativeSelection(win?: Window): Selection;
58-
getSelection(doc?: Document | Window | HTMLIFrameElement): RangySelection;
59-
addInitListener(listener: (rangy: RangyStatic) => void): any;
60-
shim(): any;
61-
createMissingNativeApi(): any;
62-
initialized: boolean;
63-
supported: boolean;
64-
}
65-
declare module "rangy" {
66-
export = rangy;
67-
}
68-
declare var rangy: RangyStatic;
1+
export {};

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

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
import "./rangy-core";
2+
3+
declare global {
4+
namespace rangy {
5+
interface RangyClassApplierOptions {
6+
elementTagName?: string;
7+
elementProperties?: { [key: string]: string };
8+
elementAttributes?: { [key: string]: string };
9+
ignoreWhiteSpace?: boolean;
10+
applyToEditableOnly?: boolean;
11+
tagNames?: string[] | string;
12+
normalize?: boolean;
13+
onElementCreate?: ((element: Element, classApplier: RangyClassApplier) => any) | undefined;
14+
useExistingElements?: boolean;
15+
}
16+
17+
interface RangyClassApplier {
18+
applyToSelection(win?: Window): void;
19+
undoToSelection(win?: Window): void;
20+
isAppliedToSelection(win?: Window): boolean;
21+
toggleSelection(win?: Window): void;
22+
applyToRange(range: RangyRange): void;
23+
undoToRange(range: RangyRange): void;
24+
isAppliedToRange(range: RangyRange): boolean;
25+
toggleRange(range: RangyRange): void;
26+
detach(doc?: Document | Window | HTMLIFrameElement): void;
27+
className: string;
28+
cssClass: string;
29+
}
30+
31+
function createClassApplier(
32+
className: string,
33+
options?: RangyClassApplierOptions,
34+
tagNames?: string[] | string,
35+
): RangyClassApplier;
36+
}
37+
}
38+
39+
export = rangy;

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

Lines changed: 152 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,152 @@
1+
export const version: string;
2+
3+
export interface RangyRange extends Range {
4+
startContainer: Node;
5+
startOffset: number;
6+
endContainer: Node;
7+
endOffset: number;
8+
commonAncestorContainer: Node;
9+
collapsed: boolean;
10+
setStart(node: Node, offset: number): void;
11+
setStartBefore(node: Node): void;
12+
setStartAfter(node: Node): void;
13+
setEnd(node: Node, offset: number): void;
14+
setEndBefore(node: Node): void;
15+
setEndAfter(node: Node): void;
16+
setStartAndEnd(startNode: Node, startOffset: number, endNode?: Node, endOffset?: number): any;
17+
selectNode(node: Node): any;
18+
selectNodeContents(node: Node): any;
19+
collapse(toStart?: boolean): void;
20+
compareBoundaryPoints(comparisonType: number, range: RangyRange): number;
21+
insertNode(node: Node): any;
22+
cloneContents(): DocumentFragment;
23+
extractContents(): DocumentFragment;
24+
deleteContents(): void;
25+
canSurroundContents(): boolean;
26+
surroundContents(node: Node): boolean;
27+
cloneRange(): RangyRange;
28+
isValid(): boolean;
29+
toString(): string;
30+
toHtml(): string;
31+
compareNode(node: Node): NodeType;
32+
comparePoint(node: Node, offset: number): -1 | 0 | 1;
33+
intersectsOrTouchesRange(range: RangyRange): boolean;
34+
intersectsRange(range: RangyRange): boolean;
35+
intersectsNode(node: Node, touchingIsIntersecting?: boolean): boolean;
36+
intersection(range: RangyRange): RangyRange | null;
37+
union(range: RangyRange): RangyRange | null;
38+
isPointInRange(node: Node, offset: number): boolean;
39+
createContextualFragment(fragment: string): DocumentFragment;
40+
containsNode(node: Node, partial: boolean): boolean;
41+
containsNodeContents(node: Node): boolean;
42+
containsNodeText(node: Node): boolean;
43+
containsRange(range: RangyRange): boolean;
44+
splitBoundaries(): any;
45+
normalizeBoundaries(): any;
46+
collapseToPoint(node: Node, offset: number): any;
47+
collapseBefore(node: Node): any;
48+
collapseAfter(node: Node): any;
49+
getNodes(nodeTypes?: any[], filter?: (node: Node) => boolean): Node[];
50+
getBookmark(containerNode?: Node): { start: number; end: number };
51+
moveToBookmark(bookmark: Object): any;
52+
getDocument(): Document;
53+
inspect(): string;
54+
equals(range: RangyRange): boolean;
55+
refresh(): any;
56+
select(): any;
57+
detach(): void;
58+
}
59+
60+
export interface RangySelection extends Selection {
61+
nativeSelection: Selection;
62+
rangeCount: number;
63+
isCollapsed: boolean;
64+
anchorNode: Node | null;
65+
anchorOffset: number;
66+
focusNode: Node | null;
67+
focusOffset: number;
68+
addRange(range: RangyRange, direction?: Direction | boolean): void;
69+
getRangeAt(index: number): RangyRange;
70+
isBackwards(): boolean;
71+
removeAllRanges(): void;
72+
removeRange(range: RangyRange): void;
73+
refresh(checkForChanges?: boolean): any;
74+
collapse(node: Node, offset: number): void;
75+
collapseToStart(): void;
76+
collapseToEnd(): void;
77+
selectAllChildren(node: Node): void;
78+
deleteFromDocument(): void;
79+
toString(): string;
80+
toHtml(): string;
81+
getAllRanges(): RangyRange[];
82+
getNativeTextRange(): Range;
83+
getSingleRange(range: RangyRange, direction: Direction): any;
84+
setRanges(ranges: RangyRange[]): any;
85+
containsNode(node: Node, partial: boolean): boolean;
86+
getBookmark(containerNode: Node): any;
87+
moveToBookmark(bookmark: Object): any;
88+
saveRanges(): Object;
89+
restoreRanges(saved: Object): any;
90+
detach(): any;
91+
inspect(): string;
92+
}
93+
94+
export type Direction = "forward" | "forwards" | "backward" | "backwards" | boolean;
95+
export type NodeType = "NODE_BEFORE" | "NODE_AFTER" | "NODE_BEFORE_AND_AFTER" | "NODE_INSIDE";
96+
97+
export interface CookieOptions {
98+
expires?: Date;
99+
path?: string;
100+
domain?: string;
101+
secure?: boolean;
102+
}
103+
104+
export interface DomPosition {
105+
node: Node;
106+
offset: number;
107+
}
108+
export type RangyStatic = typeof import("rangy");
109+
export function addInitListener(listener: (rangy: RangyStatic) => void): void;
110+
export function createMissingNativeApi(): void;
111+
export function shim(): void;
112+
export function createNativeRange(doc?: Document | Window | HTMLIFrameElement): Range;
113+
export function createRange(doc?: Document | Window | HTMLIFrameElement): RangyRange;
114+
export function createRangyRange(doc?: Document | Window | HTMLIFrameElement): RangyRange;
115+
export function getNativeSelection(win?: Window): Selection;
116+
export function getSelection(win?: Window): RangySelection;
117+
export var initialized: boolean;
118+
export var supported: boolean;
119+
export var config: {
120+
alertOnFail: boolean;
121+
alertOnWarn: boolean;
122+
checkSelectionRanges: boolean;
123+
preferTextRange: boolean;
124+
autoInitialize: boolean;
125+
};
126+
export var dom: any;
127+
export var features: {
128+
collapsedNonEditableSelectionsSupported: boolean;
129+
implementsControlRange: boolean;
130+
implementsDomRange: boolean;
131+
implementsTextRange: boolean;
132+
selectionHasAnchorAndFocus: boolean;
133+
selectionHasExtend: boolean;
134+
selectionHasRangeCount: boolean;
135+
selectionSupportsMultipleRanges: boolean;
136+
crashyTextNodes: boolean;
137+
implementsDocSelection: boolean;
138+
implementsWinGetSelection: boolean;
139+
};
140+
141+
export var util: {
142+
isHostObject(obj: any, prop: string): boolean;
143+
isHostMethod(obj: any, method: string): boolean;
144+
isHostProperty(obj: any, prop: string): boolean;
145+
areHostObjects(obj: any, props: string[]): boolean;
146+
areHostMethods(obj: any, methods: string[]): boolean;
147+
areHostProperties(obj: any, props: string[]): boolean;
148+
toArray(arrayLike: any): any[];
149+
};
150+
export function init(): void;
151+
152+
export as namespace rangy;

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

Lines changed: 49 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
1+
import "./rangy-classapplier";
2+
import "./rangy-core";
3+
4+
declare global {
5+
namespace rangy {
6+
interface RangyHighlighter {
7+
addClassApplier(classApplier: RangyClassApplier, options?: RangyHighlighterAddClassOptions): void;
8+
highlightSelection(className: string, options?: RangyHighlightOptions): string[];
9+
unhighlightSelection(selection?: RangySelection): boolean;
10+
removeAllHighlights(): void;
11+
serialize(highlights?: RangyHighlight[]): string;
12+
deserialize(serialized: string): RangyHighlight[];
13+
getHighlightForElement(el: Element): RangyHighlight | null;
14+
}
15+
16+
interface RangyHighlighterAddClassOptions {
17+
priority?: number;
18+
exclusive?: boolean;
19+
}
20+
21+
interface RangyHighlightOptions {
22+
selection?: RangySelection;
23+
exclusive?: boolean;
24+
containerElementId?: string;
25+
}
26+
27+
interface RangyHighlight {
28+
id: string;
29+
classApplier: RangyClassApplier;
30+
characterRange: {
31+
start: number;
32+
end: number;
33+
containerElement: Node;
34+
};
35+
containsElement(el: Node): boolean;
36+
containsRange(range: RangyRange): boolean;
37+
intersectsRange(range: RangyRange): boolean;
38+
isCharacterRange(containerElement: Node): boolean;
39+
getRange(containerElement?: Node): RangyRange;
40+
}
41+
42+
function createHighlighter(
43+
doc?: Document | Window | HTMLIFrameElement,
44+
type?: "textContent" | "textRange",
45+
): RangyHighlighter;
46+
}
47+
}
48+
49+
export = rangy;

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

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
import "./rangy-core";
2+
3+
declare global {
4+
namespace rangy {
5+
function saveSelection(win?: Window): object | null;
6+
function restoreSelection(savedSelection: object, preserveDirection?: boolean): boolean;
7+
function saveRange(range: Range): object;
8+
function restoreRange(savedRange: object, normalize?: boolean): Range;
9+
function saveRanges(ranges: Range[], direction?: Direction | boolean): object[];
10+
function restoreRanges(savedRanges: object[]): Range[];
11+
function removeMarkers(savedSelection: object): void;
12+
}
13+
}
14+
15+
export = rangy;

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

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
import "./rangy-core";
2+
3+
declare global {
4+
namespace rangy {
5+
function serializeSelection(selection?: RangySelection, omitChecksum?: boolean, root?: Node): string;
6+
function canDeserializeSelection(serializedSelection: string, root?: Node, win?: Window): boolean;
7+
function deserializeSelection(serializedSelection: string, root?: Node, win?: Window): RangySelection;
8+
function serializeRange(range: RangyRange, omitChecksum?: boolean, root?: Node): string;
9+
function canDeserializeRange(serializedRange: string, root?: Node, doc?: Document): boolean;
10+
function deserializeRange(serializedRange: string, root?: Node, doc?: Document): RangyRange;
11+
function serializePosition(node: Node, offset: number, root?: Node): string;
12+
function deserializePosition(serializedPosition: string, root?: Node, doc?: Document): DomPosition;
13+
function saveSelectionCookie(win?: Window, props?: CookieOptions): void;
14+
function restoreSelectionFromCookie(win?: Window): boolean;
15+
}
16+
}
17+
18+
export = rangy;

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

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
1+
import "./rangy-core";
2+
3+
declare global {
4+
namespace rangy {
5+
interface RangyWordOptions {
6+
includeTrailingSpace?: boolean;
7+
wordRegex?: RegExp;
8+
}
9+
10+
interface RangyCharacterOptions {
11+
includeBlockContentTrailingSpace?: boolean;
12+
includeSpaceBeforeBr?: boolean;
13+
includePreLineTrailingSpace?: boolean;
14+
ignoreCharacters?: string;
15+
}
16+
17+
interface RangyTextOptions extends RangyWordOptions, RangyCharacterOptions {}
18+
19+
interface RangyFindTextOptions {
20+
caseSensitive?: boolean;
21+
withinRange?: RangyRange;
22+
wholeWordsOnly?: boolean;
23+
wrap?: boolean;
24+
direction?: "forward" | "backward";
25+
wordOptions?: RangyWordOptions;
26+
characterOptions?: RangyCharacterOptions;
27+
}
28+
29+
interface RangyTextExpandOptions extends RangyTextOptions {
30+
trim?: boolean;
31+
trimStart?: boolean;
32+
trimEnd?: boolean;
33+
}
34+
35+
interface RangyTextRange {
36+
moveStart(unit: string, count: number, options?: RangyTextOptions): number;
37+
moveEnd(unit: string, count: number, options?: RangyTextOptions): number;
38+
move(unit: string, count: number, options?: RangyTextOptions): number;
39+
expand(unit: string, options?: RangyTextExpandOptions): boolean;
40+
text(): string;
41+
selectCharacters(containerNode: Node, startIndex: number, endIndex: number): void;
42+
toCharacterRange(containerNode: Node, options?: RangyTextOptions): { start: number; end: number };
43+
findText(searchTerm: string | RegExp, options?: RangyFindTextOptions): boolean;
44+
}
45+
}
46+
}
47+
48+
export = rangy;

0 commit comments

Comments
 (0)