-
Notifications
You must be signed in to change notification settings - Fork 14
/
phet-types.d.ts
157 lines (132 loc) · 5.33 KB
/
phet-types.d.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
// Copyright 2021, University of Colorado Boulder
/* eslint-disable no-var */
/**
* Ambient type declarations for PhET code. Many of these definitions can be moved/disabled once the common code is
* converted to TypeScript. Note that this file is in globals mode, so the `declare var` statements will be available
* as globals like `phetio` and also as properties on the `window` object like `window.phetio`.
*
* See also phet-types-module.d.ts which is in module mode.
*
* @author Sam Reid (PhET Interactive Simulations)
*/
// Can't externally reference
type IntentionalAny = any; // eslint-disable-line @typescript-eslint/no-explicit-any
declare var assert: undefined | ( ( x: IntentionalAny, ...messages?: IntentionalAny[] ) => void );
declare var assertSlow: undefined | ( ( x: IntentionalAny, ...messages?: IntentionalAny[] ) => void );
declare var sceneryLog: null | false | ( Record<string, ( ob: IntentionalAny, style?: string ) => void> & {
push(): void;
pop(): void;
getDepth(): number;
} );
declare var phet: Record<string, IntentionalAny>;
// TODO: This can be moved to QueryStringMachine when it is moved to TypeScript, see https://github.com/phetsims/query-string-machine/issues/49
declare type Warning = {
key: string;
value: string;
};
// Matches TYPE documentation in QueryStringMachine
declare type QueryStringMachineSchema = {
private?: boolean;
public?: boolean;
} & (
{
type: 'flag';
} |
{
type: 'boolean';
defaultValue?: boolean;
} |
{
type: 'number';
defaultValue?: number;
validValues?: readonly number[];
isValidValue?: ( n: number ) => boolean;
} |
{
type: 'string';
defaultValue?: string | null;
validValues?: readonly ( string | null )[];
isValidValue?: ( n: string | null ) => boolean;
} |
{
type: 'array';
elementSchema: QueryStringMachineSchema;
separator?: string;
defaultValue?: null | readonly IntentionalAny[];
validValues?: readonly IntentionalAny[][];
isValidValue?: ( n: IntentionalAny[] ) => boolean;
} |
{
type: 'custom';
parse: ( str: string ) => IntentionalAny;
defaultValue?: IntentionalAny;
validValues?: readonly IntentionalAny[];
isValidValue?: ( n: IntentionalAny ) => boolean;
} );
// Converts a Schema's type to the actual Typescript type it represents
declare type QueryMachineTypeToType<T> = T extends ( 'flag' | 'boolean' ) ? boolean : ( T extends 'number' ? number : ( T extends 'string' ? ( string | null ) : ( T extends 'array' ? IntentionalAny[] : IntentionalAny ) ) );
type QSMSchemaObject = Record<string, QueryStringMachineSchema>;
declare type QSMParsedParameters<SchemaMap extends QSMSchemaObject> = {
// Will return a map of the "result" types
[Property in keyof SchemaMap]: QueryMachineTypeToType<SchemaMap[ Property ][ 'type' ]>
// SCHEMA_MAP allowed to be set in types
} & { SCHEMA_MAP?: QSMSchemaObject };
declare var QueryStringMachine: {
getAll: <SchemaMap extends QSMSchemaObject>( a: SchemaMap ) => QSMParsedParameters<SchemaMap>;
getAllForString: <SchemaMap extends QSMSchemaObject>( a: SchemaMap, b: string ) => QSMParsedParameters<SchemaMap>;
get: <Schema extends QueryStringMachineSchema>( a: string, schema: Schema ) => QueryMachineTypeToType<Schema[ 'type' ]>;
containsKey: ( key: string ) => boolean;
warnings: Warning[];
addWarning: ( key: string, value: IntentionalAny, message: string ) => void;
removeKeyValuePair: ( queryString: string, key: string ) => string;
removeKeyValuePairs: ( queryString: string, keys: string[] ) => string;
appendQueryString: ( url: string, tail: string ) => string;
getForString: ( s: string, schema: QueryStringMachineSchema, s: string ) => string;
getQueryString: ( url: string ) => string;
containsKeyForString: ( key: string, s: string ) => boolean;
getSingleQueryParameterString: ( key: string, url: string ) => string | null;
getQueryParametersFromString: ( string: string ) => string[];
};
// globals used in Sim.ts
declare var phetSplashScreenDownloadComplete: () => void;
declare var TWEEN: { update: ( dt: number ) => void };
declare var phetSplashScreen: { dispose: () => void };
declare var phetio: Record<string, IntentionalAny>;
// Typing for linebreaker-1.1.0.js preload
declare type LineBreakerBreak = {
position: number;
required: boolean;
};
declare type LineBreakerType = {
nextBreak(): LineBreakerBreak | null;
// We make it iterable
[ Symbol.iterator ](): Iterator<LineBreakerBreak, undefined>;
};
declare var LineBreaker: {
new( str: string ): LineBreakerType;
};
declare var assertions: {
enableAssert: () => void;
assertionHooks: Array<() => void>;
};
// Experiment to allow accessing these off window. See https://stackoverflow.com/questions/12709074/how-do-you-explicitly-set-a-new-property-on-window-in-typescript
declare global {
interface Window { // eslint-disable-line @typescript-eslint/consistent-type-definitions
phet: typeof phet;
phetio: typeof phetio;
}
}
declare var Deno: {
readTextFileSync: ( file: string ) => string;
};
// Adapted from https://github.com/mourner/flatqueue/blob/main/index.d.ts
declare class FlatQueue<T> {
public readonly length: number;
public constructor();
public clear(): void;
public push( item: T, priority: number ): void;
public pop(): T | undefined;
public peek(): T | undefined;
public peekValue(): number | undefined;
public shrink(): void;
}