1 /// This file implements definition components that are allowed in any object-based definition — `ObjectDefinition`.
2 /// So far only constants and functions belong to plain object.
3 
4 // MARK: - Constants
5 
6 /**
7  Definition function setting the module's constants to export.
8  */
9 public func constants(_ body: @escaping () -> [String: Any?]) -> AnyDefinition {
10   return ConstantsDefinition(body: body)
11 }
12 
13 /**
14  Definition function setting the module's constants to export.
15  */
16 public func constants(_ body: @autoclosure @escaping () -> [String: Any?]) -> AnyDefinition {
17   return ConstantsDefinition(body: body)
18 }
19 
20 // MARK: - Functions
21 
22 /**
23  Function without arguments.
24  */
25 @available(*, deprecated, renamed: "asyncFunction")
26 public func function<R>(
27   _ name: String,
28   _ closure: @escaping () throws -> R
29 ) -> AnyFunction {
30   return ConcreteFunction(
31     name,
32     argTypes: [],
33     closure
34   )
35 }
36 
37 /**
38  Function with one argument.
39  */
40 @available(*, deprecated, renamed: "asyncFunction")
41 public func function<R, A0: AnyArgument>(
42   _ name: String,
43   _ closure: @escaping (A0) throws -> R
44 ) -> AnyFunction {
45   return ConcreteFunction(
46     name,
47     argTypes: [ArgumentType(A0.self)],
48     closure
49   )
50 }
51 
52 /**
53  Function with two arguments.
54  */
55 @available(*, deprecated, renamed: "asyncFunction")
56 public func function<R, A0: AnyArgument, A1: AnyArgument>(
57   _ name: String,
58   _ closure: @escaping (A0, A1) throws -> R
59 ) -> AnyFunction {
60   return ConcreteFunction(
61     name,
62     argTypes: [ArgumentType(A0.self), ArgumentType(A1.self)],
63     closure
64   )
65 }
66 
67 /**
68  Function with three arguments.
69  */
70 @available(*, deprecated, renamed: "asyncFunction")
71 public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
72   _ name: String,
73   _ closure: @escaping (A0, A1, A2) throws -> R
74 ) -> AnyFunction {
75   return ConcreteFunction(
76     name,
77     argTypes: [
78       ArgumentType(A0.self),
79       ArgumentType(A1.self),
80       ArgumentType(A2.self)
81     ],
82     closure
83   )
84 }
85 
86 /**
87  Function with four arguments.
88  */
89 @available(*, deprecated, renamed: "asyncFunction")
90 public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
91   _ name: String,
92   _ closure: @escaping (A0, A1, A2, A3) throws -> R
93 ) -> AnyFunction {
94   return ConcreteFunction(
95     name,
96     argTypes: [
97       ArgumentType(A0.self),
98       ArgumentType(A1.self),
99       ArgumentType(A2.self),
100       ArgumentType(A3.self)
101     ],
102     closure
103   )
104 }
105 
106 /**
107  Function with five arguments.
108  */
109 @available(*, deprecated, renamed: "asyncFunction")
110 public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument>(
111   _ name: String,
112   _ closure: @escaping (A0, A1, A2, A3, A4) throws -> R
113 ) -> AnyFunction {
114   return ConcreteFunction(
115     name,
116     argTypes: [
117       ArgumentType(A0.self),
118       ArgumentType(A1.self),
119       ArgumentType(A2.self),
120       ArgumentType(A3.self),
121       ArgumentType(A4.self)
122     ],
123     closure
124   )
125 }
126 
127 /**
128  Function with six arguments.
129  */
130 @available(*, deprecated, renamed: "asyncFunction")
131 public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument>(
132   _ name: String,
133   _ closure: @escaping (A0, A1, A2, A3, A4, A5) throws -> R
134 ) -> AnyFunction {
135   return ConcreteFunction(
136     name,
137     argTypes: [
138       ArgumentType(A0.self),
139       ArgumentType(A1.self),
140       ArgumentType(A2.self),
141       ArgumentType(A3.self),
142       ArgumentType(A4.self),
143       ArgumentType(A5.self)
144     ],
145     closure
146   )
147 }
148 
149 /**
150  Function with seven arguments.
151  */
152 @available(*, deprecated, renamed: "asyncFunction")
153 public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument, A6: AnyArgument>(
154   _ name: String,
155   _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6) throws -> R
156 ) -> AnyFunction {
157   return ConcreteFunction(
158     name,
159     argTypes: [
160       ArgumentType(A0.self),
161       ArgumentType(A1.self),
162       ArgumentType(A2.self),
163       ArgumentType(A3.self),
164       ArgumentType(A4.self),
165       ArgumentType(A5.self),
166       ArgumentType(A6.self)
167     ],
168     closure
169   )
170 }
171 
172 /**
173  Function with eight arguments.
174  */
175 @available(*, deprecated, renamed: "asyncFunction")
176 public func function<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument, A6: AnyArgument, A7: AnyArgument>(
177   _ name: String,
178   _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6, A7) throws -> R
179 ) -> AnyFunction {
180   return ConcreteFunction(
181     name,
182     argTypes: [
183       ArgumentType(A0.self),
184       ArgumentType(A1.self),
185       ArgumentType(A2.self),
186       ArgumentType(A3.self),
187       ArgumentType(A4.self),
188       ArgumentType(A5.self),
189       ArgumentType(A6.self),
190       ArgumentType(A7.self)
191     ],
192     closure
193   )
194 }
195 
196 // MARK: - Asynchronous functions
197 
198 /**
199  Asynchronous function without arguments.
200  */
201 public func asyncFunction<R>(
202   _ name: String,
203   _ closure: @escaping () throws -> R
204 ) -> AnyFunction {
205   return AsyncFunction(
206     name,
207     argTypes: [],
208     closure
209   )
210 }
211 
212 /**
213  Asynchronous function with one argument.
214  */
215 public func asyncFunction<R, A0: AnyArgument>(
216   _ name: String,
217   _ closure: @escaping (A0) throws -> R
218 ) -> AnyFunction {
219   return AsyncFunction(
220     name,
221     argTypes: [ArgumentType(A0.self)],
222     closure
223   )
224 }
225 
226 /**
227  Asynchronous function with two arguments.
228  */
229 public func asyncFunction<R, A0: AnyArgument, A1: AnyArgument>(
230   _ name: String,
231   _ closure: @escaping (A0, A1) throws -> R
232 ) -> AnyFunction {
233   return AsyncFunction(
234     name,
235     argTypes: [ArgumentType(A0.self), ArgumentType(A1.self)],
236     closure
237   )
238 }
239 
240 /**
241  Asynchronous function with three arguments.
242  */
243 public func asyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument>(
244   _ name: String,
245   _ closure: @escaping (A0, A1, A2) throws -> R
246 ) -> AnyFunction {
247   return AsyncFunction(
248     name,
249     argTypes: [
250       ArgumentType(A0.self),
251       ArgumentType(A1.self),
252       ArgumentType(A2.self)
253     ],
254     closure
255   )
256 }
257 
258 /**
259  Asynchronous function with four arguments.
260  */
261 public func asyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument>(
262   _ name: String,
263   _ closure: @escaping (A0, A1, A2, A3) throws -> R
264 ) -> AnyFunction {
265   return AsyncFunction(
266     name,
267     argTypes: [
268       ArgumentType(A0.self),
269       ArgumentType(A1.self),
270       ArgumentType(A2.self),
271       ArgumentType(A3.self)
272     ],
273     closure
274   )
275 }
276 
277 /**
278  Asynchronous function with five arguments.
279  */
280 public func asyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument>(
281   _ name: String,
282   _ closure: @escaping (A0, A1, A2, A3, A4) throws -> R
283 ) -> AnyFunction {
284   return AsyncFunction(
285     name,
286     argTypes: [
287       ArgumentType(A0.self),
288       ArgumentType(A1.self),
289       ArgumentType(A2.self),
290       ArgumentType(A3.self),
291       ArgumentType(A4.self)
292     ],
293     closure
294   )
295 }
296 
297 /**
298  Asynchronous function with six arguments.
299  */
300 public func asyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument>(
301   _ name: String,
302   _ closure: @escaping (A0, A1, A2, A3, A4, A5) throws -> R
303 ) -> AnyFunction {
304   return AsyncFunction(
305     name,
306     argTypes: [
307       ArgumentType(A0.self),
308       ArgumentType(A1.self),
309       ArgumentType(A2.self),
310       ArgumentType(A3.self),
311       ArgumentType(A4.self),
312       ArgumentType(A5.self)
313     ],
314     closure
315   )
316 }
317 
318 /**
319  Asynchronous function with seven arguments.
320  */
321 public func asyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument, A6: AnyArgument>(
322   _ name: String,
323   _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6) throws -> R
324 ) -> AnyFunction {
325   return AsyncFunction(
326     name,
327     argTypes: [
328       ArgumentType(A0.self),
329       ArgumentType(A1.self),
330       ArgumentType(A2.self),
331       ArgumentType(A3.self),
332       ArgumentType(A4.self),
333       ArgumentType(A5.self),
334       ArgumentType(A6.self)
335     ],
336     closure
337   )
338 }
339 
340 /**
341  Asynchronous function with eight arguments.
342  */
343 public func asyncFunction<R, A0: AnyArgument, A1: AnyArgument, A2: AnyArgument, A3: AnyArgument, A4: AnyArgument, A5: AnyArgument, A6: AnyArgument, A7: AnyArgument>(
344   _ name: String,
345   _ closure: @escaping (A0, A1, A2, A3, A4, A5, A6, A7) throws -> R
346 ) -> AnyFunction {
347   return AsyncFunction(
348     name,
349     argTypes: [
350       ArgumentType(A0.self),
351       ArgumentType(A1.self),
352       ArgumentType(A2.self),
353       ArgumentType(A3.self),
354       ArgumentType(A4.self),
355       ArgumentType(A5.self),
356       ArgumentType(A6.self),
357       ArgumentType(A7.self)
358     ],
359     closure
360   )
361 }
362 
363 // MARK: - Events
364 
365 /**
366  Defines event names that the object can send to JavaScript.
367  */
368 public func events(_ names: String...) -> AnyDefinition {
369   return EventsDefinition(names: names)
370 }
371 
372 /**
373  Function that is invoked when the first event listener is added.
374  */
375 public func onStartObserving(_ body: @escaping () -> Void) -> AnyFunction {
376   return ConcreteFunction("startObserving", argTypes: [], body)
377 }
378 
379 /**
380  Function that is invoked when all event listeners are removed.
381  */
382 public func onStopObserving(_ body: @escaping () -> Void) -> AnyFunction {
383   return ConcreteFunction("stopObserving", argTypes: [], body)
384 }
385