@needle-tools/needle-component-compiler 1.6.3 → 1.7.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. package/Changelog.md +12 -0
  2. package/package.json +1 -1
  3. package/src/component-compiler.js +173 -54
  4. package/src/component-compiler.ts +174 -46
  5. package/src/test.ts +27 -3
  6. package/src/types.js +2 -0
package/Changelog.md CHANGED
@@ -4,6 +4,18 @@ All notable changes to this package will be documented in this file.
4
4
  The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
5
5
  and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
6
6
 
7
+ ## [1.7.1] - 2022-07-27
8
+ - fix UnityEvent codegen
9
+
10
+ ## [1.7.1] - 2022-07-25
11
+ - fix array type codegen, for example ``scenes: Array<AssetReference> = [];``, see issue https://github.com/needle-tools/needle-tiny-playground/issues/285
12
+
13
+ ## [1.7.0] - 2022-07-14
14
+ - change: skip non-serializeable variables (private without ``@serializable``)
15
+ - improve member type generation
16
+ - fix bug in type generation for array types
17
+ - add/improve initial assignment codegen for object types
18
+
7
19
  ## [1.6.3] - 2022-07-12
8
20
  - add warning when class type is unknown
9
21
 
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@needle-tools/needle-component-compiler",
3
- "version": "1.6.3",
3
+ "version": "1.7.2",
4
4
  "description": "Compile mock unity components from typescript",
5
5
  "main": "index.js",
6
6
  "scripts": {
package/src/component-compiler.js CHANGED
@@ -218,13 +218,28 @@ function run(program, outputDir, sourceFile) {
218
218
  break;
219
219
  console.log("Found variable", node.getText());
220
220
  var vardec = node;
221
+ var varName = "@" + vardec.name.getText();
222
+ var pub = isPublic(vardec);
223
+ var visibility = pub ? "public" : "private";
224
+ var isAccessible = pub;
225
+ if (!pub && serializeField) {
226
+ console.log("[SerializeField]");
227
+ context.appendLine("[UnityEngine.SerializeField]");
228
+ isAccessible = true;
229
+ }
230
+ if (!isAccessible) {
231
+ console.log("Skip because not public or serializeable");
232
+ break;
233
+ }
221
234
  var name_1 = vardec.name.getText();
222
- console.log(name_1);
235
+ console.log("Variable:", name_1);
223
236
  if (name_1.startsWith("\"@") || name_1.startsWith("\"$") || name_1.startsWith("$"))
224
237
  break;
225
238
  var typeString = lastTypeFound !== null && lastTypeFound !== void 0 ? lastTypeFound : tryResolveTypeRecursive(node);
239
+ var postFix = "";
240
+ var typeName = (_c = vardec.type) === null || _c === void 0 ? void 0 : _c.getText();
226
241
  if (typeString === undefined) {
227
- context.append("// Could not resolve type \"" + ((_c = vardec.type) === null || _c === void 0 ? void 0 : _c.getText()) + "\"\n");
242
+ postFix = " → Could not resolve C# type";
228
243
  }
229
244
  var prefix = typeString === undefined ? "// " : "";
230
245
  var assignment = "";
@@ -232,6 +247,12 @@ function run(program, outputDir, sourceFile) {
232
247
  for (var _j = 0, _k = node.getChildren(); _j < _k.length; _j++) {
233
248
  var ch = _k[_j];
234
249
  switch (ch.kind) {
250
+ default:
251
+ // console.log("Unknown assignment:", ts.SyntaxKind[ch.kind]);
252
+ break;
253
+ case ts.SyntaxKind.NewExpression:
254
+ assignment = " = " + getTypeForAssignment(ch);
255
+ break;
235
256
  case ts.SyntaxKind.FalseKeyword:
236
257
  case ts.SyntaxKind.TrueKeyword:
237
258
  assignment = " = " + ch.getText();
@@ -248,24 +269,23 @@ function run(program, outputDir, sourceFile) {
248
269
  break;
249
270
  case ts.SyntaxKind.ArrayLiteralExpression:
250
271
  var arr = ch;
251
- assignment = " = new " + typeString + "{" + arr.elements.map(function (e) { return " " + e.getText(); }) + " }";
272
+ assignment = " = new " + typeString;
273
+ // if (arr.elements.length > 0) {
274
+ assignment += "{" + arr.elements.map(function (e) { return " " + getTypeForAssignment(e); }) + " }";
275
+ // }
252
276
  break;
253
277
  }
254
278
  }
255
279
  }
256
- var varName = "@" + vardec.name.getText();
257
- var pub = isPublic(vardec);
258
- var visibility = pub ? "public" : "private";
259
- if (!pub && serializeField) {
260
- console.log("SERIALIZE");
261
- context.appendLine("[UnityEngine.SerializeField]");
262
- }
263
280
  var requireEndIf = false;
264
281
  if (ifdefSections.length > 0) {
265
282
  requireEndIf = true;
266
283
  context.appendLine("#ifdef " + ifdefSections.pop());
267
284
  }
268
- context.append(prefix + visibility + " " + typeString + " " + varName + assignment + ";\n");
285
+ if (typeString === undefined)
286
+ typeString = typeName;
287
+ console.log("EMIT member: " + typeString + " " + varName);
288
+ context.append(prefix + visibility + " " + typeString + " " + varName + assignment + ";" + postFix + "\n");
269
289
  lastTypeFound = null;
270
290
  if (requireEndIf) {
271
291
  context.appendLine("#endif");
@@ -291,13 +311,13 @@ function run(program, outputDir, sourceFile) {
291
311
  newContext.appendLine("{");
292
312
  newContext.indentLevel += 1;
293
313
  // newContext.appendLine("// source: " + path.resolve(sourceFile.fileName));
294
- var typeName = "UnityEngine.MonoBehaviour";
314
+ var typeName_1 = "UnityEngine.MonoBehaviour";
295
315
  if (typeof inheritsComponent === "string")
296
- typeName = inheritsComponent;
316
+ typeName_1 = inheritsComponent;
297
317
  if (lastTypeFound)
298
- typeName = lastTypeFound;
299
- console.log(name_2 + " inherits " + typeName);
300
- newContext.appendLine("public partial class " + name_2 + " : " + typeName);
318
+ typeName_1 = lastTypeFound;
319
+ console.log(name_2 + " inherits " + typeName_1);
320
+ newContext.appendLine("public partial class " + name_2 + " : " + typeName_1);
301
321
  newContext.appendLine("{");
302
322
  newContext.indentLevel += 1;
303
323
  newContext.classEnd = dec.end;
@@ -337,6 +357,39 @@ function run(program, outputDir, sourceFile) {
337
357
  }
338
358
  return false;
339
359
  }
360
+ function getTypeForAssignment(node) {
361
+ // console.log("-------------------\nAssign", ts.SyntaxKind[node.kind]);
362
+ switch (node.kind) {
363
+ case ts.SyntaxKind.FirstLiteralToken:
364
+ return node.getText();
365
+ case ts.SyntaxKind.NewExpression:
366
+ var type = undefined;
367
+ var args = undefined;
368
+ for (var _i = 0, _a = node.getChildren(); _i < _a.length; _i++) {
369
+ var ch = _a[_i];
370
+ var text = ch.getText();
371
+ // console.log("child", ts.SyntaxKind[ch.kind], text);
372
+ switch (ch.kind) {
373
+ case ts.SyntaxKind.Identifier:
374
+ case ts.SyntaxKind.PropertyAccessExpression:
375
+ type = tryGetTypeFromText(text);
376
+ break;
377
+ case ts.SyntaxKind.SyntaxList:
378
+ args = text;
379
+ break;
380
+ }
381
+ }
382
+ if (!args)
383
+ args = "";
384
+ if (type)
385
+ return "new " + type + "(" + args + ")";
386
+ // const expType = node.getChildren().find(c => c.kind === ts.SyntaxKind.Identifier);
387
+ break;
388
+ }
389
+ var str = node.getText();
390
+ console.log("Unknown assignment:", str, ts.SyntaxKind[node.kind]);
391
+ return str;
392
+ }
340
393
  function isPublic(node) {
341
394
  if (node.kind === ts.SyntaxKind.PublicKeyword) {
342
395
  return true;
@@ -376,8 +429,21 @@ function run(program, outputDir, sourceFile) {
376
429
  }
377
430
  return namespace;
378
431
  }
432
+ function tryGetTypeFromText(typeName) {
433
+ var res = dict[typeName];
434
+ if (res === undefined) {
435
+ switch (typeName) {
436
+ case "Array":
437
+ break;
438
+ default:
439
+ var knownType = tryGetKnownType(typeName);
440
+ res = knownType !== null && knownType !== void 0 ? knownType : undefined;
441
+ break;
442
+ }
443
+ }
444
+ return res;
445
+ }
379
446
  function tryResolveTypeRecursive(node) {
380
- var _a;
381
447
  if (!node)
382
448
  return undefined;
383
449
  // skip decorators (e.g. @serializable() may break array generation)
@@ -388,58 +454,111 @@ function run(program, outputDir, sourceFile) {
388
454
  if (varDec.type) {
389
455
  typeName = varDec.type.getText();
390
456
  }
391
- var res = dict[typeName];
392
- if (res !== undefined) {
393
- // console.log("FOUND " + res, ts.SyntaxKind[node.kind]);
394
- // console.log(node);
395
- return res;
396
- }
397
- var knownType = tryGetKnownType(typeName);
398
- if (knownType)
399
- return knownType;
457
+ var res = undefined;
400
458
  // console.log("Unknown type: " + typeName);
401
459
  switch (node.kind) {
402
- case ts.SyntaxKind.SyntaxList:
403
- // const list = node as ts.SyntaxList;
404
- // for(const ch of list._children)
405
- // res = tryResolveTypeRecursive(ch);
406
- break;
460
+ // case ts.SyntaxKind.SyntaxList:
461
+ // const list = node as ts.SyntaxList;
462
+ // for (const ch of list._children) {
463
+ // res = tryResolveTypeRecursive(ch);
464
+ // }
465
+ // break;
407
466
  case ts.SyntaxKind.UnionType:
408
467
  var union = node;
409
- for (var _i = 0, _b = union.types; _i < _b.length; _i++) {
410
- var t = _b[_i];
468
+ for (var _i = 0, _a = union.types; _i < _a.length; _i++) {
469
+ var t = _a[_i];
411
470
  res = tryResolveTypeRecursive(t);
412
471
  if (res !== undefined)
413
472
  return res;
414
473
  }
415
474
  break;
416
475
  case ts.SyntaxKind.ArrayType:
417
- var arrayType = node;
418
- var typeName_1 = (_a = arrayType.elementType) === null || _a === void 0 ? void 0 : _a.getText();
419
- if (typeName_1 !== undefined) {
420
- res = dict[typeName_1];
421
- if (res !== undefined) {
422
- res += "[]";
423
- return res;
424
- }
476
+ res = "[]";
477
+ break;
478
+ case ts.SyntaxKind.TypeReference:
479
+ var typeRef = node;
480
+ var typeName_2 = typeRef.typeName.getText();
481
+ console.log("TypeReference:", typeName_2);
482
+ switch (typeName_2) {
483
+ case "Array":
484
+ break;
485
+ default:
486
+ return tryGetTypeFromText(typeName_2);
487
+ }
488
+ // return res;
489
+ break;
490
+ case ts.SyntaxKind.BooleanKeyword:
491
+ case ts.SyntaxKind.NumberKeyword:
492
+ case ts.SyntaxKind.StringKeyword:
493
+ case ts.SyntaxKind.ObjectKeyword:
494
+ var keyword = node.getText();
495
+ // the basic keywords are declared in the static dictionary
496
+ // no need for a complex lookup
497
+ res = dict[keyword];
498
+ break;
499
+ case ts.SyntaxKind.Identifier:
500
+ var id = node;
501
+ switch (id.text) {
502
+ // if we have an array we dont want to use the System.Array as a type but just make it to the array syntax
503
+ case "Array":
504
+ res = "[]";
505
+ break;
506
+ default:
507
+ // console.log(id.text);
508
+ // res = tryGetTypeFromText(id.text);
509
+ break;
425
510
  }
426
- }
427
- for (var _c = 0, _d = node.getChildren(); _c < _d.length; _c++) {
428
- var child = _d[_c];
429
- if (res !== undefined)
430
511
  break;
431
- console.log("Child type: " + ts.SyntaxKind[child.kind]);
432
- res = tryResolveTypeRecursive(child);
433
512
  }
434
- if (ts.isTypeReferenceNode(node)) {
435
- var typeRef = node;
436
- var typeName_2 = typeRef.typeName.getText();
437
- switch (typeName_2) {
438
- case "Array":
439
- res += "[]";
440
- return res;
513
+ var isInGenericDeclaration = false;
514
+ for (var _b = 0, _c = node.getChildren(); _b < _c.length; _b++) {
515
+ var child = _c[_b];
516
+ // if (res !== undefined) break;
517
+ // console.log("Child type: " + ts.SyntaxKind[child.kind]);
518
+ var isGenericStart = false;
519
+ var isAssignment = false;
520
+ switch (child.kind) {
521
+ case ts.SyntaxKind.FirstAssignment:
522
+ isAssignment = true;
523
+ break;
524
+ case ts.SyntaxKind.FirstBinaryOperator:
525
+ // console.log("Generic start: " + child.getText());
526
+ isInGenericDeclaration = true;
527
+ isGenericStart = true;
528
+ break;
529
+ case ts.SyntaxKind.GreaterThanGreaterThanToken:
530
+ isInGenericDeclaration = false;
531
+ // console.log("Generic end: " + child.getText());
532
+ break;
533
+ }
534
+ // if (isAssignment) break;
535
+ var childResult = tryResolveTypeRecursive(child);
536
+ if (childResult !== undefined) {
537
+ if (res === undefined)
538
+ res = "";
539
+ console.log("Child: " + ts.SyntaxKind[child.kind] + " → " + childResult);
540
+ // if the thing is a generic return as generic result
541
+ if (isInGenericDeclaration && !res.includes("[]")) {
542
+ res = "<" + childResult + ">";
543
+ }
544
+ // we got a generic result, these need to be appended
545
+ else if (childResult.startsWith("<")) {
546
+ res += childResult;
547
+ }
548
+ // concat default
549
+ else
550
+ res = childResult + res;
441
551
  }
442
552
  }
553
+ // if (ts.isTypeReferenceNode(node)) {
554
+ // const typeRef = node as ts.TypeReferenceNode;
555
+ // const typeName = typeRef.typeName.getText();
556
+ // switch (typeName) {
557
+ // case "Array":
558
+ // res += "[]";
559
+ // return res;
560
+ // }
561
+ // }
443
562
  return res;
444
563
  }
445
564
  }
package/src/component-compiler.ts CHANGED
@@ -30,7 +30,6 @@ function resetExportNextClass() {
30
30
 
31
31
  let typesFileContent: object | undefined | null = undefined;
32
32
  function tryGetKnownType(str: string): string | null {
33
-
34
33
  if (typesFileContent === undefined) {
35
34
  typesFileContent = null;
36
35
  const filePath = path.dirname(__dirname) + "/src/types.json";
@@ -241,18 +240,41 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
241
240
  if (!context) break;
242
241
  console.log("Found variable", node.getText());
243
242
  const vardec = node as ts.VariableDeclaration;
243
+
244
+ const varName = "@" + vardec.name.getText();
245
+ const pub = isPublic(vardec);
246
+ const visibility = pub ? "public" : "private";
247
+ let isAccessible = pub;
248
+ if (!pub && serializeField) {
249
+ console.log("[SerializeField]");
250
+ context.appendLine("[UnityEngine.SerializeField]");
251
+ isAccessible = true;
252
+ }
253
+ if (!isAccessible) {
254
+ console.log("Skip because not public or serializeable")
255
+ break;
256
+ }
257
+
244
258
  const name = vardec.name.getText();
245
- console.log(name);
259
+ console.log("Variable:", name);
246
260
  if (name.startsWith("\"@") || name.startsWith("\"$") || name.startsWith("$")) break;
247
261
  let typeString = lastTypeFound ?? tryResolveTypeRecursive(node);
262
+ let postFix = "";
263
+ let typeName = vardec.type?.getText();
248
264
  if (typeString === undefined) {
249
- context.append("// Could not resolve type \"" + vardec.type?.getText() + "\"\n");
265
+ postFix = " → Could not resolve C# type";
250
266
  }
251
267
  const prefix = typeString === undefined ? "// " : "";
252
268
  let assignment = "";
253
269
  if (typeString !== undefined) {
254
270
  for (const ch of node.getChildren()) {
255
271
  switch (ch.kind) {
272
+ default:
273
+ // console.log("Unknown assignment:", ts.SyntaxKind[ch.kind]);
274
+ break;
275
+ case ts.SyntaxKind.NewExpression:
276
+ assignment = " = " + getTypeForAssignment(ch);
277
+ break;
256
278
  case ts.SyntaxKind.FalseKeyword:
257
279
  case ts.SyntaxKind.TrueKeyword:
258
280
  assignment = " = " + ch.getText();
@@ -269,24 +291,22 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
269
291
  break;
270
292
  case ts.SyntaxKind.ArrayLiteralExpression:
271
293
  const arr = ch as ts.ArrayLiteralExpression;
272
- assignment = " = new " + typeString + "{" + arr.elements.map(e => " " + e.getText()) + " }"
294
+ assignment = " = new " + typeString;
295
+ // if (arr.elements.length > 0) {
296
+ assignment += "{" + arr.elements.map(e => " " + getTypeForAssignment(e)) + " }";
297
+ // }
273
298
  break;
274
299
  }
275
300
  }
276
301
  }
277
- const varName = "@" + vardec.name.getText();
278
- const pub = isPublic(vardec);
279
- const visibility = pub ? "public" : "private";
280
- if (!pub && serializeField) {
281
- console.log("SERIALIZE");
282
- context.appendLine("[UnityEngine.SerializeField]");
283
- }
284
302
  let requireEndIf = false;
285
303
  if (ifdefSections.length > 0) {
286
304
  requireEndIf = true;
287
305
  context.appendLine("#ifdef " + ifdefSections.pop());
288
306
  }
289
- context.append(prefix + visibility + " " + typeString + " " + varName + assignment + ";\n");
307
+ if (typeString === undefined) typeString = typeName;
308
+ console.log("EMIT member: " + typeString + " " + varName)
309
+ context.append(prefix + visibility + " " + typeString + " " + varName + assignment + ";" + postFix + "\n");
290
310
  lastTypeFound = null;
291
311
  if (requireEndIf) {
292
312
  context.appendLine("#endif");
@@ -353,6 +373,38 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
353
373
  return false;
354
374
  }
355
375
 
376
+ function getTypeForAssignment(node: ts.Node) {
377
+ // console.log("-------------------\nAssign", ts.SyntaxKind[node.kind]);
378
+ switch (node.kind) {
379
+ case ts.SyntaxKind.FirstLiteralToken:
380
+ return node.getText();
381
+ case ts.SyntaxKind.NewExpression:
382
+ let type: string | undefined = undefined;
383
+ let args: string | undefined = undefined;
384
+ for (const ch of node.getChildren()) {
385
+ const text = ch.getText();
386
+ // console.log("child", ts.SyntaxKind[ch.kind], text);
387
+ switch (ch.kind) {
388
+ case ts.SyntaxKind.Identifier:
389
+ case ts.SyntaxKind.PropertyAccessExpression:
390
+ type = tryGetTypeFromText(text);
391
+ break;
392
+ case ts.SyntaxKind.SyntaxList:
393
+ args = text;
394
+ break;
395
+ }
396
+ }
397
+ if (!args) args = "";
398
+ if (type)
399
+ return "new " + type + "(" + args + ")";
400
+ // const expType = node.getChildren().find(c => c.kind === ts.SyntaxKind.Identifier);
401
+ break;
402
+ }
403
+ const str = node.getText();
404
+ console.log("Unknown assignment:", str, ts.SyntaxKind[node.kind]);
405
+ return str;
406
+ }
407
+
356
408
  function isPublic(node: ts.Node): boolean {
357
409
  if (node.kind === ts.SyntaxKind.PublicKeyword) {
358
410
  return true;
@@ -391,6 +443,21 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
391
443
  return namespace;
392
444
  }
393
445
 
446
+ function tryGetTypeFromText(typeName: string) {
447
+ let res = dict[typeName];
448
+ if (res === undefined) {
449
+ switch (typeName) {
450
+ case "Array":
451
+ break;
452
+ default:
453
+ const knownType = tryGetKnownType(typeName);
454
+ res = knownType ?? undefined;
455
+ break;
456
+ }
457
+ }
458
+ return res;
459
+ }
460
+
394
461
  function tryResolveTypeRecursive(node: ts.Node | ts.VariableDeclaration): string | undefined {
395
462
  if (!node) return undefined;
396
463
 
@@ -405,23 +472,19 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
405
472
  typeName = varDec.type.getText();
406
473
  }
407
474
 
408
- let res = dict[typeName];
409
- if (res !== undefined) {
410
- // console.log("FOUND " + res, ts.SyntaxKind[node.kind]);
411
- // console.log(node);
412
- return res;
413
- }
414
- const knownType = tryGetKnownType(typeName);
415
- if (knownType)
416
- return knownType;
475
+ let res: string | undefined = undefined;
476
+
477
+
478
+
417
479
  // console.log("Unknown type: " + typeName);
418
480
 
419
481
  switch (node.kind) {
420
- case ts.SyntaxKind.SyntaxList:
421
- // const list = node as ts.SyntaxList;
422
- // for(const ch of list._children)
423
- // res = tryResolveTypeRecursive(ch);
424
- break;
482
+ // case ts.SyntaxKind.SyntaxList:
483
+ // const list = node as ts.SyntaxList;
484
+ // for (const ch of list._children) {
485
+ // res = tryResolveTypeRecursive(ch);
486
+ // }
487
+ // break;
425
488
  case ts.SyntaxKind.UnionType:
426
489
  const union = node as ts.UnionTypeNode;
427
490
  for (const t of union.types) {
@@ -429,33 +492,98 @@ export function run(program: ts.Program, outputDir: string, sourceFile: ts.Sourc
429
492
  if (res !== undefined) return res;
430
493
  }
431
494
  break;
495
+
432
496
  case ts.SyntaxKind.ArrayType:
433
- const arrayType = <ts.ArrayTypeNode>node;
434
- const typeName = arrayType.elementType?.getText();
435
- if (typeName !== undefined) {
436
- res = dict[typeName];
437
- if (res !== undefined) {
438
- res += "[]";
439
- return res;
440
- }
497
+ res = "[]";
498
+ break;
499
+
500
+ case ts.SyntaxKind.TypeReference:
501
+ const typeRef = node as ts.TypeReferenceNode;
502
+ const typeName = typeRef.typeName.getText();
503
+ console.log("TypeReference:", typeName);
504
+ switch (typeName) {
505
+ case "Array":
506
+ break;
507
+ default:
508
+ return tryGetTypeFromText(typeName);
441
509
  }
442
- }
510
+ // return res;
511
+ break;
443
512
 
444
- for (const child of node.getChildren()) {
445
- if (res !== undefined) break;
446
- console.log("Child type: " + ts.SyntaxKind[child.kind]);
447
- res = tryResolveTypeRecursive(child);
513
+ case ts.SyntaxKind.BooleanKeyword:
514
+ case ts.SyntaxKind.NumberKeyword:
515
+ case ts.SyntaxKind.StringKeyword:
516
+ case ts.SyntaxKind.ObjectKeyword:
517
+ const keyword = node.getText();
518
+ // the basic keywords are declared in the static dictionary
519
+ // no need for a complex lookup
520
+ res = dict[keyword];
521
+ break;
522
+
523
+ case ts.SyntaxKind.Identifier:
524
+ const id = node as ts.Identifier;
525
+ switch (id.text) {
526
+ // if we have an array we dont want to use the System.Array as a type but just make it to the array syntax
527
+ case "Array":
528
+ res = "[]";
529
+ break;
530
+ default:
531
+ // console.log(id.text);
532
+ // res = tryGetTypeFromText(id.text);
533
+ break;
534
+ }
535
+ break;
448
536
  }
449
537
 
450
- if (ts.isTypeReferenceNode(node)) {
451
- const typeRef = node as ts.TypeReferenceNode;
452
- const typeName = typeRef.typeName.getText();
453
- switch (typeName) {
454
- case "Array":
455
- res += "[]";
456
- return res;
538
+ let isInGenericDeclaration = false;
539
+ for (const child of node.getChildren()) {
540
+ // if (res !== undefined) break;
541
+ // console.log("Child type: " + ts.SyntaxKind[child.kind]);
542
+ let isGenericStart = false;
543
+ let isAssignment = false;
544
+ switch (child.kind) {
545
+ case ts.SyntaxKind.FirstAssignment:
546
+ isAssignment = true;
547
+ break;
548
+ case ts.SyntaxKind.FirstBinaryOperator:
549
+ // console.log("Generic start: " + child.getText());
550
+ isInGenericDeclaration = true;
551
+ isGenericStart = true;
552
+ break;
553
+ case ts.SyntaxKind.GreaterThanGreaterThanToken:
554
+ isInGenericDeclaration = false;
555
+ // console.log("Generic end: " + child.getText());
556
+ break;
557
+ }
558
+ // if (isAssignment) break;
559
+ const childResult = tryResolveTypeRecursive(child);
560
+ if (childResult !== undefined) {
561
+ if (res === undefined) res = "";
562
+ console.log("Child: " + ts.SyntaxKind[child.kind] + " → " + childResult);
563
+ // if the thing is a generic return as generic result
564
+ if (isInGenericDeclaration && !res.includes("[]")) {
565
+ res = "<" + childResult + ">";
566
+ }
567
+ // we got a generic result, these need to be appended
568
+ else if (childResult.startsWith("<")) {
569
+ res += childResult;
570
+ }
571
+ // concat default
572
+ else
573
+ res = childResult + res;
457
574
  }
458
575
  }
576
+
577
+ // if (ts.isTypeReferenceNode(node)) {
578
+ // const typeRef = node as ts.TypeReferenceNode;
579
+ // const typeName = typeRef.typeName.getText();
580
+ // switch (typeName) {
581
+ // case "Array":
582
+ // res += "[]";
583
+ // return res;
584
+ // }
585
+ // }
586
+
459
587
  return res;
460
588
  }
461
589
  }
package/src/test.ts CHANGED
@@ -1,9 +1,33 @@
1
+ import { ThisExpression } from "typescript";
1
2
 
2
- class Test123 {}
3
3
 
4
- export class Bla extends Test123
5
- {
4
+
5
+ export class EventComponent extends Behaviour {
6
+ @serializeable(EventList)
7
+ roomChanged: EventList = new EventList();
8
+ }
9
+
10
+ export class SocLoader extends Behaviour {
6
11
 
12
+ @serializeable(AssetReference)
13
+ scenes: Array<AssetReference> = [];
14
+ }
15
+ // class Test123 {}
16
+
17
+ export class Bla extends Behaviour
18
+ {
19
+ myNumber:number = 42;
20
+ myBool:boolean = true;
21
+ myString:string = "test";
22
+ numberArr: number[] = [1,2,3];
23
+ myColor : THREE.Color = new THREE.Color(255, 0, 0);
24
+ renderers = new Array<Renderer>();
25
+ renderers2 : Renderer[] = [];
26
+ objArr : object[];
27
+ colArr: THREE.Color[] = [new THREE.Color(1,2,3)];
28
+ map : Map<string> = new Map<string>();
29
+ map2 : Map<object> = new Map<object>();
30
+ private myThing : Test123;
7
31
  }
8
32
 
9
33
  // //@type UnityEngine.MonoBehaviour
package/src/types.js CHANGED
@@ -3,9 +3,11 @@ exports.__esModule = true;
3
3
  exports.delint = void 0;
4
4
 
5
5
  const dict = {
6
+ "object" : "UnityEngine.Object",
6
7
  "number": "float",
7
8
  "string": "string",
8
9
  "boolean": "bool",
10
+ "Map" : "System.Collections.Generic.HashSet",
9
11
  // basic
10
12
  "Behaviour" : "UnityEngine.Behaviour",
11
13
  "Component" : "UnityEngine.Component",