@travetto/transformer 7.0.0-rc.2 → 7.0.0-rc.4

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 (7) hide show
  1. package/README.md +2 -7
  2. package/package.json +3 -2
  3. package/src/register.ts +52 -53
  4. package/src/resolver/builder.ts +9 -2
  5. package/src/resolver/types.ts +4 -0
  6. package/src/state.ts +1 -1
  7. package/src/util/doc.ts +0 -1
package/README.md CHANGED
@@ -95,13 +95,9 @@ export class Test {
95
95
 
96
96
  **Code: Sample Output**
97
97
  ```javascript
98
- "use strict";
99
- Object.defineProperty(exports, "__esModule", { value: true });
100
- exports.TEST = void 0;
101
- const tslib_1 = require("tslib");
102
- const Δfunction = tslib_1.__importStar(require("@travetto/runtime/src/function.js"));
98
+ import * as Δfunction from "@travetto/runtime/src/function.js";
103
99
  var mod_1 = ["@travetto/transformer", "doc/upper.ts"];
104
- class TEST {
100
+ export class TEST {
105
101
  static { Δfunction.registerFunction(TEST, mod_1, { hash: 649563175, lines: [1, 9] }, { COMPUTEAGE: { hash: 1286718349, lines: [6, 8, 7] } }, false); }
106
102
  NAME;
107
103
  AGE;
@@ -110,5 +106,4 @@ class TEST {
110
106
  this['AGE'] = (Date.now() - this.DOB.getTime());
111
107
  }
112
108
  }
113
- exports.TEST = TEST;
114
109
  ```
package/package.json CHANGED
@@ -1,6 +1,7 @@
1
1
  {
2
2
  "name": "@travetto/transformer",
3
- "version": "7.0.0-rc.2",
3
+ "version": "7.0.0-rc.4",
4
+ "type": "module",
4
5
  "description": "Functionality for AST transformations, with transformer registration, and general utils",
5
6
  "keywords": [
6
7
  "typescript",
@@ -24,7 +25,7 @@
24
25
  "directory": "module/transformer"
25
26
  },
26
27
  "dependencies": {
27
- "@travetto/manifest": "^7.0.0-rc.1",
28
+ "@travetto/manifest": "^7.0.0-rc.3",
28
29
  "tslib": "^2.8.1",
29
30
  "typescript": "^5.9.3"
30
31
  },
package/src/register.ts CHANGED
@@ -39,8 +39,8 @@ function storeHandler(cls: TransformerWithHandlers, fn: Function, phase: Transfo
39
39
  */
40
40
  export function OnFile(...target: string[]) {
41
41
  return <S extends State = State, R extends ts.Node = ts.Node>(
42
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.SourceFile) => R>
43
- ): void => storeHandler(inst, descriptor.value!, 'before', 'file', target);
42
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.SourceFile) => R>
43
+ ): void => storeHandler(instance, descriptor.value!, 'before', 'file', target);
44
44
  }
45
45
 
46
46
  /**
@@ -48,8 +48,8 @@ export function OnFile(...target: string[]) {
48
48
  */
49
49
  export function AfterFile(...target: string[]) {
50
50
  return <S extends State = State, R extends ts.Node = ts.Node>(
51
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.SourceFile) => R>
52
- ): void => storeHandler(inst, descriptor.value!, 'before', 'file', target);
51
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.SourceFile) => R>
52
+ ): void => storeHandler(instance, descriptor.value!, 'before', 'file', target);
53
53
  }
54
54
 
55
55
  /**
@@ -57,8 +57,8 @@ export function AfterFile(...target: string[]) {
57
57
  */
58
58
  export function OnCall(...target: string[]) {
59
59
  return <S extends State = State, R extends ts.Node = ts.Node>(
60
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.CallExpression) => R>
61
- ): void => storeHandler(inst, descriptor.value!, 'before', 'call', target);
60
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.CallExpression) => R>
61
+ ): void => storeHandler(instance, descriptor.value!, 'before', 'call', target);
62
62
  }
63
63
 
64
64
  /**
@@ -66,8 +66,8 @@ export function OnCall(...target: string[]) {
66
66
  */
67
67
  export function OnFunction(...target: string[]) {
68
68
  return <S extends State = State, R extends ts.Node = ts.Node>(
69
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.FunctionDeclaration | ts.FunctionExpression) => R>
70
- ): void => storeHandler(inst, descriptor.value!, 'before', 'function', target);
69
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.FunctionDeclaration | ts.FunctionExpression) => R>
70
+ ): void => storeHandler(instance, descriptor.value!, 'before', 'function', target);
71
71
  }
72
72
 
73
73
  /**
@@ -75,8 +75,8 @@ export function OnFunction(...target: string[]) {
75
75
  */
76
76
  export function OnParameter(...target: string[]) {
77
77
  return <S extends State = State, R extends ts.Node = ts.Node>(
78
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ParameterDeclaration, dm?: DecoratorMeta) => R>
79
- ): void => storeHandler(inst, descriptor.value!, 'before', 'parameter', target);
78
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ParameterDeclaration, meta?: DecoratorMeta) => R>
79
+ ): void => storeHandler(instance, descriptor.value!, 'before', 'parameter', target);
80
80
  }
81
81
 
82
82
  /**
@@ -84,8 +84,8 @@ export function OnParameter(...target: string[]) {
84
84
  */
85
85
  export function OnProperty(...target: string[]) {
86
86
  return <S extends State = State, R extends ts.Node = ts.Node>(
87
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.PropertyDeclaration, dm?: DecoratorMeta) => R>
88
- ): void => storeHandler(inst, descriptor.value!, 'before', 'property', target);
87
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.PropertyDeclaration, meta?: DecoratorMeta) => R>
88
+ ): void => storeHandler(instance, descriptor.value!, 'before', 'property', target);
89
89
  }
90
90
 
91
91
  /**
@@ -93,8 +93,8 @@ export function OnProperty(...target: string[]) {
93
93
  */
94
94
  export function OnGetter(...target: string[]) {
95
95
  return <S extends State = State, R extends ts.Node = ts.Node>(
96
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.GetAccessorDeclaration, dm?: DecoratorMeta) => R>
97
- ): void => storeHandler(inst, descriptor.value!, 'before', 'getter', target);
96
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.GetAccessorDeclaration, meta?: DecoratorMeta) => R>
97
+ ): void => storeHandler(instance, descriptor.value!, 'before', 'getter', target);
98
98
  }
99
99
 
100
100
  /**
@@ -102,8 +102,8 @@ export function OnGetter(...target: string[]) {
102
102
  */
103
103
  export function OnSetter(...target: string[]) {
104
104
  return <S extends State = State, R extends ts.Node = ts.Node>(
105
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.SetAccessorDeclaration, dm?: DecoratorMeta) => R>
106
- ): void => storeHandler(inst, descriptor.value!, 'before', 'setter', target);
105
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.SetAccessorDeclaration, meta?: DecoratorMeta) => R>
106
+ ): void => storeHandler(instance, descriptor.value!, 'before', 'setter', target);
107
107
  }
108
108
 
109
109
  /**
@@ -111,8 +111,8 @@ export function OnSetter(...target: string[]) {
111
111
  */
112
112
  export function OnMethod(...target: string[]) {
113
113
  return <S extends State = State, R extends ts.Node = ts.Node>(
114
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, dm?: DecoratorMeta) => R>
115
- ): void => storeHandler(inst, descriptor.value!, 'before', 'method', target);
114
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, meta?: DecoratorMeta) => R>
115
+ ): void => storeHandler(instance, descriptor.value!, 'before', 'method', target);
116
116
  }
117
117
 
118
118
  /**
@@ -120,8 +120,8 @@ export function OnMethod(...target: string[]) {
120
120
  */
121
121
  export function OnConstructor(...target: string[]) {
122
122
  return <S extends State = State, R extends ts.Node = ts.Node>(
123
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ConstructorDeclaration, dm?: DecoratorMeta) => R>
124
- ): void => storeHandler(inst, descriptor.value!, 'before', 'constructor', target);
123
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ConstructorDeclaration, meta?: DecoratorMeta) => R>
124
+ ): void => storeHandler(instance, descriptor.value!, 'before', 'constructor', target);
125
125
  }
126
126
 
127
127
  /**
@@ -129,8 +129,8 @@ export function OnConstructor(...target: string[]) {
129
129
  */
130
130
  export function OnStaticMethod(...target: string[]) {
131
131
  return <S extends State = State, R extends ts.Node = ts.Node>(
132
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, dm?: DecoratorMeta) => R>
133
- ): void => storeHandler(inst, descriptor.value!, 'before', 'static-method', target);
132
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, meta?: DecoratorMeta) => R>
133
+ ): void => storeHandler(instance, descriptor.value!, 'before', 'static-method', target);
134
134
  }
135
135
 
136
136
  /**
@@ -138,8 +138,8 @@ export function OnStaticMethod(...target: string[]) {
138
138
  */
139
139
  export function OnClass(...target: string[]) {
140
140
  return <S extends State = State, R extends ts.Node = ts.Node>(
141
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ClassDeclaration, dm?: DecoratorMeta) => R>
142
- ): void => storeHandler(inst, descriptor.value!, 'before', 'class', target);
141
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ClassDeclaration, meta?: DecoratorMeta) => R>
142
+ ): void => storeHandler(instance, descriptor.value!, 'before', 'class', target);
143
143
  }
144
144
 
145
145
  /**
@@ -147,8 +147,8 @@ export function OnClass(...target: string[]) {
147
147
  */
148
148
  export function OnTypeAlias(...target: string[]) {
149
149
  return <S extends State = State, R extends ts.Node = ts.Node>(
150
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.TypeAliasDeclaration) => R>
151
- ): void => storeHandler(inst, descriptor.value!, 'before', 'type', target);
150
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.TypeAliasDeclaration) => R>
151
+ ): void => storeHandler(instance, descriptor.value!, 'before', 'type', target);
152
152
  }
153
153
 
154
154
  /**
@@ -156,8 +156,8 @@ export function OnTypeAlias(...target: string[]) {
156
156
  */
157
157
  export function OnInterface(...target: string[]) {
158
158
  return <S extends State = State, R extends ts.Node = ts.Node>(
159
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.InterfaceDeclaration) => R>
160
- ): void => storeHandler(inst, descriptor.value!, 'before', 'interface', target);
159
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.InterfaceDeclaration) => R>
160
+ ): void => storeHandler(instance, descriptor.value!, 'before', 'interface', target);
161
161
  }
162
162
 
163
163
  /**
@@ -165,8 +165,8 @@ export function OnInterface(...target: string[]) {
165
165
  */
166
166
  export function AfterCall(...target: string[]) {
167
167
  return <S extends State = State, R extends ts.Node = ts.Node>(
168
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.CallExpression, dm?: DecoratorMeta) => R>
169
- ): void => storeHandler(inst, descriptor.value!, 'after', 'call', target);
168
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.CallExpression, meta?: DecoratorMeta) => R>
169
+ ): void => storeHandler(instance, descriptor.value!, 'after', 'call', target);
170
170
  }
171
171
 
172
172
  /**
@@ -174,8 +174,8 @@ export function AfterCall(...target: string[]) {
174
174
  */
175
175
  export function AfterFunction(...target: string[]) {
176
176
  return <S extends State = State, R extends ts.Node = ts.Node>(
177
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.FunctionDeclaration | ts.FunctionExpression) => R>
178
- ): void => storeHandler(inst, descriptor.value!, 'after', 'function', target);
177
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.FunctionDeclaration | ts.FunctionExpression) => R>
178
+ ): void => storeHandler(instance, descriptor.value!, 'after', 'function', target);
179
179
  }
180
180
 
181
181
  /**
@@ -183,8 +183,8 @@ export function AfterFunction(...target: string[]) {
183
183
  */
184
184
  export function AfterParameter(...target: string[]) {
185
185
  return <S extends State = State, R extends ts.Node = ts.Node>(
186
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ParameterDeclaration, dm?: DecoratorMeta) => R>
187
- ): void => storeHandler(inst, descriptor.value!, 'after', 'parameter', target);
186
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ParameterDeclaration, meta?: DecoratorMeta) => R>
187
+ ): void => storeHandler(instance, descriptor.value!, 'after', 'parameter', target);
188
188
  }
189
189
 
190
190
  /**
@@ -192,8 +192,8 @@ export function AfterParameter(...target: string[]) {
192
192
  */
193
193
  export function AfterProperty(...target: string[]) {
194
194
  return <S extends State = State, R extends ts.Node = ts.Node>(
195
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.PropertyDeclaration, dm?: DecoratorMeta) => R>
196
- ): void => storeHandler(inst, descriptor.value!, 'after', 'property', target);
195
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.PropertyDeclaration, meta?: DecoratorMeta) => R>
196
+ ): void => storeHandler(instance, descriptor.value!, 'after', 'property', target);
197
197
  }
198
198
 
199
199
  /**
@@ -201,8 +201,8 @@ export function AfterProperty(...target: string[]) {
201
201
  */
202
202
  export function AfterGetter(...target: string[]) {
203
203
  return <S extends State = State, R extends ts.Node = ts.Node>(
204
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.GetAccessorDeclaration, dm?: DecoratorMeta) => R>
205
- ): void => storeHandler(inst, descriptor.value!, 'after', 'getter', target);
204
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.GetAccessorDeclaration, meta?: DecoratorMeta) => R>
205
+ ): void => storeHandler(instance, descriptor.value!, 'after', 'getter', target);
206
206
  }
207
207
 
208
208
  /**
@@ -210,8 +210,8 @@ export function AfterGetter(...target: string[]) {
210
210
  */
211
211
  export function AfterSetter(...target: string[]) {
212
212
  return <S extends State = State, R extends ts.Node = ts.Node>(
213
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.SetAccessorDeclaration, dm?: DecoratorMeta) => R>
214
- ): void => storeHandler(inst, descriptor.value!, 'after', 'setter', target);
213
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.SetAccessorDeclaration, meta?: DecoratorMeta) => R>
214
+ ): void => storeHandler(instance, descriptor.value!, 'after', 'setter', target);
215
215
  }
216
216
 
217
217
  /**
@@ -219,8 +219,8 @@ export function AfterSetter(...target: string[]) {
219
219
  */
220
220
  export function AfterMethod(...target: string[]) {
221
221
  return <S extends State = State, R extends ts.Node = ts.Node>(
222
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, dm?: DecoratorMeta) => R>
223
- ): void => storeHandler(inst, descriptor.value!, 'after', 'method', target);
222
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, meta?: DecoratorMeta) => R>
223
+ ): void => storeHandler(instance, descriptor.value!, 'after', 'method', target);
224
224
  }
225
225
 
226
226
  /**
@@ -228,8 +228,8 @@ export function AfterMethod(...target: string[]) {
228
228
  */
229
229
  export function AfterConstructor(...target: string[]) {
230
230
  return <S extends State = State, R extends ts.Node = ts.Node>(
231
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ConstructorDeclaration, dm?: DecoratorMeta) => R>
232
- ): void => storeHandler(inst, descriptor.value!, 'after', 'constructor', target);
231
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ConstructorDeclaration, meta?: DecoratorMeta) => R>
232
+ ): void => storeHandler(instance, descriptor.value!, 'after', 'constructor', target);
233
233
  }
234
234
 
235
235
  /**
@@ -237,8 +237,8 @@ export function AfterConstructor(...target: string[]) {
237
237
  */
238
238
  export function AfterStaticMethod(...target: string[]) {
239
239
  return <S extends State = State, R extends ts.Node = ts.Node>(
240
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, dm?: DecoratorMeta) => R>
241
- ): void => storeHandler(inst, descriptor.value!, 'after', 'static-method', target);
240
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.MethodDeclaration, meta?: DecoratorMeta) => R>
241
+ ): void => storeHandler(instance, descriptor.value!, 'after', 'static-method', target);
242
242
  }
243
243
 
244
244
  /**
@@ -246,18 +246,17 @@ export function AfterStaticMethod(...target: string[]) {
246
246
  */
247
247
  export function AfterClass(...target: string[]) {
248
248
  return <S extends State = State, R extends ts.Node = ts.Node>(
249
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ClassDeclaration, dm?: DecoratorMeta) => R>
250
- ): void => storeHandler(inst, descriptor.value!, 'after', 'class', target);
249
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.ClassDeclaration, meta?: DecoratorMeta) => R>
250
+ ): void => storeHandler(instance, descriptor.value!, 'after', 'class', target);
251
251
  }
252
252
 
253
-
254
253
  /**
255
254
  * Listens for a `ts.TypeAliasDeclaration` on ascent
256
255
  */
257
256
  export function AfterTypeAlias(...target: string[]) {
258
257
  return <S extends State = State, R extends ts.Node = ts.Node>(
259
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.TypeAliasDeclaration) => R>
260
- ): void => storeHandler(inst, descriptor.value!, 'after', 'type', target);
258
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.TypeAliasDeclaration) => R>
259
+ ): void => storeHandler(instance, descriptor.value!, 'after', 'type', target);
261
260
  }
262
261
 
263
262
  /**
@@ -265,6 +264,6 @@ export function AfterTypeAlias(...target: string[]) {
265
264
  */
266
265
  export function AfterInterface(...target: string[]) {
267
266
  return <S extends State = State, R extends ts.Node = ts.Node>(
268
- inst: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.InterfaceDeclaration) => R>
269
- ): void => storeHandler(inst, descriptor.value!, 'after', 'interface', target);
267
+ instance: Transformer, __: unknown, descriptor: TypedPropertyDescriptor<(state: S, node: ts.InterfaceDeclaration) => R>
268
+ ): void => storeHandler(instance, descriptor.value!, 'after', 'interface', target);
270
269
  }
package/src/resolver/builder.ts CHANGED
@@ -86,6 +86,13 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
86
86
  return { category: 'foreign', type };
87
87
  }
88
88
  } catch { }
89
+
90
+ const text = resolver.getTypeAsString(type);
91
+ if (flags & (ts.SymbolFlags.TypeAlias | ts.SymbolFlags.ExportValue)
92
+ && text?.startsWith('typeof')
93
+ ) {
94
+ return { category: 'managed', type }
95
+ }
89
96
  return { category: 'shape', type };
90
97
  } else if (objectFlags & (ts.ObjectFlags.Reference | ts.ObjectFlags.Class | ts.ObjectFlags.Interface)) {
91
98
  let resolvedType = type;
@@ -103,7 +110,7 @@ export function TypeCategorize(resolver: TransformResolver, type: ts.Type): { ca
103
110
  return { category: 'literal', type };
104
111
  } else if (sourceFile && ManifestModuleUtil.TYPINGS_EXT_REGEX.test(sourceFile) && !resolver.isKnownFile(sourceFile)) {
105
112
  return { category: 'foreign', type: resolvedType };
106
- } else if (!resolvedType.isClass()) { // Not a real type
113
+ } else if (!resolvedType.isClass()) { // Not a real type
107
114
  return { category: 'shape', type: resolvedType };
108
115
  } else {
109
116
  return { category: 'managed', type: resolvedType };
@@ -207,7 +214,7 @@ export const TypeBuilder: {
207
214
  build: (resolver, type) => {
208
215
  const name = CoreUtil.getSymbol(type)?.getName();
209
216
  const source = DeclarationUtil.getPrimaryDeclarationNode(type).getSourceFile();
210
- return { key: 'foreign', name, source: source.fileName };
217
+ return { key: 'foreign', name, source: source.fileName, classId: `${source.fileName.split('node_modules/')[1]}+${name}` };
211
218
  }
212
219
  },
213
220
  managed: {
package/src/resolver/types.ts CHANGED
@@ -191,6 +191,10 @@ export interface ForeignType extends Type<'foreign'> {
191
191
  * Primary source file
192
192
  */
193
193
  source: string;
194
+ /**
195
+ * Unique class identifier
196
+ */
197
+ classId: string;
194
198
  }
195
199
 
196
200
  /**
package/src/state.ts CHANGED
@@ -409,7 +409,7 @@ export class TransformerState implements State {
409
409
  file.identifier,
410
410
  this.factory.createIdentifier('foreignType'),
411
411
  ), [], [
412
- this.fromLiteral(`${type.source.split('node_modules/')[1]}+${type.name}`)
412
+ this.fromLiteral(type.classId)
413
413
  ]);
414
414
  }
415
415
 
package/src/util/doc.ts CHANGED
@@ -84,7 +84,6 @@ export class DocUtil {
84
84
  return tags.some(tag => tag.name === name);
85
85
  }
86
86
 
87
-
88
87
  /**
89
88
  * Read augments information
90
89
  * @param type