nestia 3.1.4-dev.20221021 → 3.1.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.
|
@@ -62,490 +62,475 @@ var NestiaConfig;
|
|
|
62
62
|
if (typeof loaded !== "object")
|
|
63
63
|
throw new Error("Error on NestiaConfig.get(): failed to load data");
|
|
64
64
|
const config = typeof loaded.default === "object" ? loaded.default : loaded;
|
|
65
|
-
return (input => {
|
|
66
|
-
const $
|
|
65
|
+
return (input => {
|
|
66
|
+
const $guard = typescript_json_1.assertType.guard;
|
|
67
67
|
const $join = typescript_json_1.assertType.join;
|
|
68
|
-
|
|
69
|
-
(input, path, exceptionable) =>
|
|
70
|
-
path: path + ".input
|
|
71
|
-
expected: "string",
|
|
72
|
-
value:
|
|
73
|
-
}))
|
|
68
|
+
((input, path, exceptionable) => {
|
|
69
|
+
const $ao0 = (input, path, exceptionable) => (null !== input.input || $guard(exceptionable, {
|
|
70
|
+
path: path + ".input",
|
|
71
|
+
expected: "(Array<string> | Resolve<IConfiguration.IInput> | string)",
|
|
72
|
+
value: input.input
|
|
73
|
+
})) && (undefined !== input.input || $guard(exceptionable, {
|
|
74
|
+
path: path + ".input",
|
|
75
|
+
expected: "(Array<string> | Resolve<IConfiguration.IInput> | string)",
|
|
76
|
+
value: input.input
|
|
77
|
+
})) && ("string" === typeof input.input || (Array.isArray(input.input) || $guard(exceptionable, {
|
|
74
78
|
path: path + ".input",
|
|
75
79
|
expected: "(Array<string> | Resolve<IConfiguration.IInput> | string)",
|
|
76
80
|
value: input.input
|
|
77
|
-
}))
|
|
81
|
+
})) && input.input.every((elem, index1) => "string" === typeof elem || $guard(exceptionable, {
|
|
82
|
+
path: path + ".input[" + index1 + "]",
|
|
83
|
+
expected: "string",
|
|
84
|
+
value: elem
|
|
85
|
+
})) || ("object" === typeof input.input && null !== input.input || $guard(exceptionable, {
|
|
78
86
|
path: path + ".input",
|
|
79
87
|
expected: "(Array<string> | Resolve<IConfiguration.IInput> | string)",
|
|
80
88
|
value: input.input
|
|
81
|
-
})) && $
|
|
89
|
+
})) && $ao1(input.input, path + ".input", true && exceptionable)) && (undefined === input.output || "string" === typeof input.output || $guard(exceptionable, {
|
|
82
90
|
path: path + ".output",
|
|
83
91
|
expected: "(string | undefined)",
|
|
84
92
|
value: input.output
|
|
85
|
-
})) &&
|
|
93
|
+
})) && (undefined === input.compilerOptions || ("object" === typeof input.compilerOptions && null !== input.compilerOptions || $guard(exceptionable, {
|
|
86
94
|
path: path + ".compilerOptions",
|
|
87
95
|
expected: "(Resolve<__type.o1> | undefined)",
|
|
88
96
|
value: input.compilerOptions
|
|
89
|
-
})),
|
|
90
|
-
path: path + ".compilerOptions",
|
|
91
|
-
expected: "(Resolve<__type.o1> | undefined)",
|
|
92
|
-
value: input.compilerOptions
|
|
93
|
-
})) && $predicate(undefined === input.assert || "boolean" === typeof input.assert, exceptionable, () => ({
|
|
97
|
+
})) && $ao2(input.compilerOptions, path + ".compilerOptions", true && exceptionable)) && (undefined === input.assert || "boolean" === typeof input.assert || $guard(exceptionable, {
|
|
94
98
|
path: path + ".assert",
|
|
95
99
|
expected: "(boolean | undefined)",
|
|
96
100
|
value: input.assert
|
|
97
|
-
})) &&
|
|
101
|
+
})) && (undefined === input.json || "boolean" === typeof input.json || $guard(exceptionable, {
|
|
98
102
|
path: path + ".json",
|
|
99
103
|
expected: "(boolean | undefined)",
|
|
100
104
|
value: input.json
|
|
101
|
-
})) &&
|
|
105
|
+
})) && (undefined === input.primitive || "boolean" === typeof input.primitive || $guard(exceptionable, {
|
|
102
106
|
path: path + ".primitive",
|
|
103
107
|
expected: "(boolean | undefined)",
|
|
104
108
|
value: input.primitive
|
|
105
|
-
})) &&
|
|
109
|
+
})) && (undefined === input.swagger || ("object" === typeof input.swagger && null !== input.swagger || $guard(exceptionable, {
|
|
106
110
|
path: path + ".swagger",
|
|
107
111
|
expected: "(Resolve<IConfiguration.ISwagger> | undefined)",
|
|
108
112
|
value: input.swagger
|
|
109
|
-
})),
|
|
110
|
-
|
|
111
|
-
expected: "(Resolve<IConfiguration.ISwagger> | undefined)",
|
|
112
|
-
value: input.swagger
|
|
113
|
-
})),
|
|
114
|
-
(input, path, exceptionable) => $predicate(Array.isArray(input.include) && input.include.every((elem, index2) => $predicate("string" === typeof elem, exceptionable, () => ({
|
|
115
|
-
path: path + ".include[" + index2 + "]",
|
|
116
|
-
expected: "string",
|
|
117
|
-
value: elem
|
|
118
|
-
}))), exceptionable, () => ({
|
|
113
|
+
})) && $ao4(input.swagger, path + ".swagger", true && exceptionable));
|
|
114
|
+
const $ao1 = (input, path, exceptionable) => (Array.isArray(input.include) || $guard(exceptionable, {
|
|
119
115
|
path: path + ".include",
|
|
120
116
|
expected: "Array<string>",
|
|
121
117
|
value: input.include
|
|
122
|
-
})) &&
|
|
123
|
-
path: path + ".
|
|
118
|
+
})) && input.include.every((elem, index2) => "string" === typeof elem || $guard(exceptionable, {
|
|
119
|
+
path: path + ".include[" + index2 + "]",
|
|
124
120
|
expected: "string",
|
|
125
121
|
value: elem
|
|
126
|
-
}))
|
|
122
|
+
})) && (undefined === input.exclude || (Array.isArray(input.exclude) || $guard(exceptionable, {
|
|
127
123
|
path: path + ".exclude",
|
|
128
124
|
expected: "(Array<string> | undefined)",
|
|
129
125
|
value: input.exclude
|
|
130
|
-
})),
|
|
131
|
-
|
|
126
|
+
})) && input.exclude.every((elem, index3) => "string" === typeof elem || $guard(exceptionable, {
|
|
127
|
+
path: path + ".exclude[" + index3 + "]",
|
|
128
|
+
expected: "string",
|
|
129
|
+
value: elem
|
|
130
|
+
})));
|
|
131
|
+
const $ao2 = (input, path, exceptionable) => (undefined === input.allowJs || "boolean" === typeof input.allowJs || $guard(exceptionable, {
|
|
132
132
|
path: path + ".allowJs",
|
|
133
133
|
expected: "(boolean | undefined)",
|
|
134
134
|
value: input.allowJs
|
|
135
|
-
})) &&
|
|
135
|
+
})) && (undefined === input.allowSyntheticDefaultImports || "boolean" === typeof input.allowSyntheticDefaultImports || $guard(exceptionable, {
|
|
136
136
|
path: path + ".allowSyntheticDefaultImports",
|
|
137
137
|
expected: "(boolean | undefined)",
|
|
138
138
|
value: input.allowSyntheticDefaultImports
|
|
139
|
-
})) &&
|
|
139
|
+
})) && (undefined === input.allowUmdGlobalAccess || "boolean" === typeof input.allowUmdGlobalAccess || $guard(exceptionable, {
|
|
140
140
|
path: path + ".allowUmdGlobalAccess",
|
|
141
141
|
expected: "(boolean | undefined)",
|
|
142
142
|
value: input.allowUmdGlobalAccess
|
|
143
|
-
})) &&
|
|
143
|
+
})) && (undefined === input.allowUnreachableCode || "boolean" === typeof input.allowUnreachableCode || $guard(exceptionable, {
|
|
144
144
|
path: path + ".allowUnreachableCode",
|
|
145
145
|
expected: "(boolean | undefined)",
|
|
146
146
|
value: input.allowUnreachableCode
|
|
147
|
-
})) &&
|
|
147
|
+
})) && (undefined === input.allowUnusedLabels || "boolean" === typeof input.allowUnusedLabels || $guard(exceptionable, {
|
|
148
148
|
path: path + ".allowUnusedLabels",
|
|
149
149
|
expected: "(boolean | undefined)",
|
|
150
150
|
value: input.allowUnusedLabels
|
|
151
|
-
})) &&
|
|
151
|
+
})) && (undefined === input.alwaysStrict || "boolean" === typeof input.alwaysStrict || $guard(exceptionable, {
|
|
152
152
|
path: path + ".alwaysStrict",
|
|
153
153
|
expected: "(boolean | undefined)",
|
|
154
154
|
value: input.alwaysStrict
|
|
155
|
-
})) &&
|
|
155
|
+
})) && (undefined === input.baseUrl || "string" === typeof input.baseUrl || $guard(exceptionable, {
|
|
156
156
|
path: path + ".baseUrl",
|
|
157
157
|
expected: "(string | undefined)",
|
|
158
158
|
value: input.baseUrl
|
|
159
|
-
})) &&
|
|
159
|
+
})) && (undefined === input.charset || "string" === typeof input.charset || $guard(exceptionable, {
|
|
160
160
|
path: path + ".charset",
|
|
161
161
|
expected: "(string | undefined)",
|
|
162
162
|
value: input.charset
|
|
163
|
-
})) &&
|
|
163
|
+
})) && (undefined === input.checkJs || "boolean" === typeof input.checkJs || $guard(exceptionable, {
|
|
164
164
|
path: path + ".checkJs",
|
|
165
165
|
expected: "(boolean | undefined)",
|
|
166
166
|
value: input.checkJs
|
|
167
|
-
})) &&
|
|
167
|
+
})) && (undefined === input.declaration || "boolean" === typeof input.declaration || $guard(exceptionable, {
|
|
168
168
|
path: path + ".declaration",
|
|
169
169
|
expected: "(boolean | undefined)",
|
|
170
170
|
value: input.declaration
|
|
171
|
-
})) &&
|
|
171
|
+
})) && (undefined === input.declarationMap || "boolean" === typeof input.declarationMap || $guard(exceptionable, {
|
|
172
172
|
path: path + ".declarationMap",
|
|
173
173
|
expected: "(boolean | undefined)",
|
|
174
174
|
value: input.declarationMap
|
|
175
|
-
})) &&
|
|
175
|
+
})) && (undefined === input.emitDeclarationOnly || "boolean" === typeof input.emitDeclarationOnly || $guard(exceptionable, {
|
|
176
176
|
path: path + ".emitDeclarationOnly",
|
|
177
177
|
expected: "(boolean | undefined)",
|
|
178
178
|
value: input.emitDeclarationOnly
|
|
179
|
-
})) &&
|
|
179
|
+
})) && (undefined === input.declarationDir || "string" === typeof input.declarationDir || $guard(exceptionable, {
|
|
180
180
|
path: path + ".declarationDir",
|
|
181
181
|
expected: "(string | undefined)",
|
|
182
182
|
value: input.declarationDir
|
|
183
|
-
})) &&
|
|
183
|
+
})) && (undefined === input.disableSizeLimit || "boolean" === typeof input.disableSizeLimit || $guard(exceptionable, {
|
|
184
184
|
path: path + ".disableSizeLimit",
|
|
185
185
|
expected: "(boolean | undefined)",
|
|
186
186
|
value: input.disableSizeLimit
|
|
187
|
-
})) &&
|
|
187
|
+
})) && (undefined === input.disableSourceOfProjectReferenceRedirect || "boolean" === typeof input.disableSourceOfProjectReferenceRedirect || $guard(exceptionable, {
|
|
188
188
|
path: path + ".disableSourceOfProjectReferenceRedirect",
|
|
189
189
|
expected: "(boolean | undefined)",
|
|
190
190
|
value: input.disableSourceOfProjectReferenceRedirect
|
|
191
|
-
})) &&
|
|
191
|
+
})) && (undefined === input.disableSolutionSearching || "boolean" === typeof input.disableSolutionSearching || $guard(exceptionable, {
|
|
192
192
|
path: path + ".disableSolutionSearching",
|
|
193
193
|
expected: "(boolean | undefined)",
|
|
194
194
|
value: input.disableSolutionSearching
|
|
195
|
-
})) &&
|
|
195
|
+
})) && (undefined === input.disableReferencedProjectLoad || "boolean" === typeof input.disableReferencedProjectLoad || $guard(exceptionable, {
|
|
196
196
|
path: path + ".disableReferencedProjectLoad",
|
|
197
197
|
expected: "(boolean | undefined)",
|
|
198
198
|
value: input.disableReferencedProjectLoad
|
|
199
|
-
})) &&
|
|
199
|
+
})) && (undefined === input.downlevelIteration || "boolean" === typeof input.downlevelIteration || $guard(exceptionable, {
|
|
200
200
|
path: path + ".downlevelIteration",
|
|
201
201
|
expected: "(boolean | undefined)",
|
|
202
202
|
value: input.downlevelIteration
|
|
203
|
-
})) &&
|
|
203
|
+
})) && (undefined === input.emitBOM || "boolean" === typeof input.emitBOM || $guard(exceptionable, {
|
|
204
204
|
path: path + ".emitBOM",
|
|
205
205
|
expected: "(boolean | undefined)",
|
|
206
206
|
value: input.emitBOM
|
|
207
|
-
})) &&
|
|
207
|
+
})) && (undefined === input.emitDecoratorMetadata || "boolean" === typeof input.emitDecoratorMetadata || $guard(exceptionable, {
|
|
208
208
|
path: path + ".emitDecoratorMetadata",
|
|
209
209
|
expected: "(boolean | undefined)",
|
|
210
210
|
value: input.emitDecoratorMetadata
|
|
211
|
-
})) &&
|
|
211
|
+
})) && (undefined === input.exactOptionalPropertyTypes || "boolean" === typeof input.exactOptionalPropertyTypes || $guard(exceptionable, {
|
|
212
212
|
path: path + ".exactOptionalPropertyTypes",
|
|
213
213
|
expected: "(boolean | undefined)",
|
|
214
214
|
value: input.exactOptionalPropertyTypes
|
|
215
|
-
})) &&
|
|
215
|
+
})) && (undefined === input.experimentalDecorators || "boolean" === typeof input.experimentalDecorators || $guard(exceptionable, {
|
|
216
216
|
path: path + ".experimentalDecorators",
|
|
217
217
|
expected: "(boolean | undefined)",
|
|
218
218
|
value: input.experimentalDecorators
|
|
219
|
-
})) &&
|
|
219
|
+
})) && (undefined === input.forceConsistentCasingInFileNames || "boolean" === typeof input.forceConsistentCasingInFileNames || $guard(exceptionable, {
|
|
220
220
|
path: path + ".forceConsistentCasingInFileNames",
|
|
221
221
|
expected: "(boolean | undefined)",
|
|
222
222
|
value: input.forceConsistentCasingInFileNames
|
|
223
|
-
})) &&
|
|
223
|
+
})) && (undefined === input.importHelpers || "boolean" === typeof input.importHelpers || $guard(exceptionable, {
|
|
224
224
|
path: path + ".importHelpers",
|
|
225
225
|
expected: "(boolean | undefined)",
|
|
226
226
|
value: input.importHelpers
|
|
227
|
-
})) && true &&
|
|
227
|
+
})) && true && (undefined === input.inlineSourceMap || "boolean" === typeof input.inlineSourceMap || $guard(exceptionable, {
|
|
228
228
|
path: path + ".inlineSourceMap",
|
|
229
229
|
expected: "(boolean | undefined)",
|
|
230
230
|
value: input.inlineSourceMap
|
|
231
|
-
})) &&
|
|
231
|
+
})) && (undefined === input.inlineSources || "boolean" === typeof input.inlineSources || $guard(exceptionable, {
|
|
232
232
|
path: path + ".inlineSources",
|
|
233
233
|
expected: "(boolean | undefined)",
|
|
234
234
|
value: input.inlineSources
|
|
235
|
-
})) &&
|
|
235
|
+
})) && (undefined === input.isolatedModules || "boolean" === typeof input.isolatedModules || $guard(exceptionable, {
|
|
236
236
|
path: path + ".isolatedModules",
|
|
237
237
|
expected: "(boolean | undefined)",
|
|
238
238
|
value: input.isolatedModules
|
|
239
|
-
})) && true &&
|
|
239
|
+
})) && true && (undefined === input.keyofStringsOnly || "boolean" === typeof input.keyofStringsOnly || $guard(exceptionable, {
|
|
240
240
|
path: path + ".keyofStringsOnly",
|
|
241
241
|
expected: "(boolean | undefined)",
|
|
242
242
|
value: input.keyofStringsOnly
|
|
243
|
-
})) &&
|
|
244
|
-
path: path + ".lib[" + index4 + "]",
|
|
245
|
-
expected: "string",
|
|
246
|
-
value: elem
|
|
247
|
-
}))), exceptionable, () => ({
|
|
243
|
+
})) && (undefined === input.lib || (Array.isArray(input.lib) || $guard(exceptionable, {
|
|
248
244
|
path: path + ".lib",
|
|
249
245
|
expected: "(Array<string> | undefined)",
|
|
250
246
|
value: input.lib
|
|
251
|
-
})) &&
|
|
247
|
+
})) && input.lib.every((elem, index4) => "string" === typeof elem || $guard(exceptionable, {
|
|
248
|
+
path: path + ".lib[" + index4 + "]",
|
|
249
|
+
expected: "string",
|
|
250
|
+
value: elem
|
|
251
|
+
}))) && (undefined === input.locale || "string" === typeof input.locale || $guard(exceptionable, {
|
|
252
252
|
path: path + ".locale",
|
|
253
253
|
expected: "(string | undefined)",
|
|
254
254
|
value: input.locale
|
|
255
|
-
})) &&
|
|
255
|
+
})) && (undefined === input.mapRoot || "string" === typeof input.mapRoot || $guard(exceptionable, {
|
|
256
256
|
path: path + ".mapRoot",
|
|
257
257
|
expected: "(string | undefined)",
|
|
258
258
|
value: input.mapRoot
|
|
259
|
-
})) && true && true && true &&
|
|
260
|
-
path: path + ".moduleSuffixes[" + index5 + "]",
|
|
261
|
-
expected: "string",
|
|
262
|
-
value: elem
|
|
263
|
-
}))), exceptionable, () => ({
|
|
259
|
+
})) && true && true && true && (undefined === input.moduleSuffixes || (Array.isArray(input.moduleSuffixes) || $guard(exceptionable, {
|
|
264
260
|
path: path + ".moduleSuffixes",
|
|
265
261
|
expected: "(Array<string> | undefined)",
|
|
266
262
|
value: input.moduleSuffixes
|
|
267
|
-
})) &&
|
|
263
|
+
})) && input.moduleSuffixes.every((elem, index5) => "string" === typeof elem || $guard(exceptionable, {
|
|
264
|
+
path: path + ".moduleSuffixes[" + index5 + "]",
|
|
265
|
+
expected: "string",
|
|
266
|
+
value: elem
|
|
267
|
+
}))) && true && true && (undefined === input.noEmit || "boolean" === typeof input.noEmit || $guard(exceptionable, {
|
|
268
268
|
path: path + ".noEmit",
|
|
269
269
|
expected: "(boolean | undefined)",
|
|
270
270
|
value: input.noEmit
|
|
271
|
-
})) &&
|
|
271
|
+
})) && (undefined === input.noEmitHelpers || "boolean" === typeof input.noEmitHelpers || $guard(exceptionable, {
|
|
272
272
|
path: path + ".noEmitHelpers",
|
|
273
273
|
expected: "(boolean | undefined)",
|
|
274
274
|
value: input.noEmitHelpers
|
|
275
|
-
})) &&
|
|
275
|
+
})) && (undefined === input.noEmitOnError || "boolean" === typeof input.noEmitOnError || $guard(exceptionable, {
|
|
276
276
|
path: path + ".noEmitOnError",
|
|
277
277
|
expected: "(boolean | undefined)",
|
|
278
278
|
value: input.noEmitOnError
|
|
279
|
-
})) &&
|
|
279
|
+
})) && (undefined === input.noErrorTruncation || "boolean" === typeof input.noErrorTruncation || $guard(exceptionable, {
|
|
280
280
|
path: path + ".noErrorTruncation",
|
|
281
281
|
expected: "(boolean | undefined)",
|
|
282
282
|
value: input.noErrorTruncation
|
|
283
|
-
})) &&
|
|
283
|
+
})) && (undefined === input.noFallthroughCasesInSwitch || "boolean" === typeof input.noFallthroughCasesInSwitch || $guard(exceptionable, {
|
|
284
284
|
path: path + ".noFallthroughCasesInSwitch",
|
|
285
285
|
expected: "(boolean | undefined)",
|
|
286
286
|
value: input.noFallthroughCasesInSwitch
|
|
287
|
-
})) &&
|
|
287
|
+
})) && (undefined === input.noImplicitAny || "boolean" === typeof input.noImplicitAny || $guard(exceptionable, {
|
|
288
288
|
path: path + ".noImplicitAny",
|
|
289
289
|
expected: "(boolean | undefined)",
|
|
290
290
|
value: input.noImplicitAny
|
|
291
|
-
})) &&
|
|
291
|
+
})) && (undefined === input.noImplicitReturns || "boolean" === typeof input.noImplicitReturns || $guard(exceptionable, {
|
|
292
292
|
path: path + ".noImplicitReturns",
|
|
293
293
|
expected: "(boolean | undefined)",
|
|
294
294
|
value: input.noImplicitReturns
|
|
295
|
-
})) &&
|
|
295
|
+
})) && (undefined === input.noImplicitThis || "boolean" === typeof input.noImplicitThis || $guard(exceptionable, {
|
|
296
296
|
path: path + ".noImplicitThis",
|
|
297
297
|
expected: "(boolean | undefined)",
|
|
298
298
|
value: input.noImplicitThis
|
|
299
|
-
})) &&
|
|
299
|
+
})) && (undefined === input.noStrictGenericChecks || "boolean" === typeof input.noStrictGenericChecks || $guard(exceptionable, {
|
|
300
300
|
path: path + ".noStrictGenericChecks",
|
|
301
301
|
expected: "(boolean | undefined)",
|
|
302
302
|
value: input.noStrictGenericChecks
|
|
303
|
-
})) &&
|
|
303
|
+
})) && (undefined === input.noUnusedLocals || "boolean" === typeof input.noUnusedLocals || $guard(exceptionable, {
|
|
304
304
|
path: path + ".noUnusedLocals",
|
|
305
305
|
expected: "(boolean | undefined)",
|
|
306
306
|
value: input.noUnusedLocals
|
|
307
|
-
})) &&
|
|
307
|
+
})) && (undefined === input.noUnusedParameters || "boolean" === typeof input.noUnusedParameters || $guard(exceptionable, {
|
|
308
308
|
path: path + ".noUnusedParameters",
|
|
309
309
|
expected: "(boolean | undefined)",
|
|
310
310
|
value: input.noUnusedParameters
|
|
311
|
-
})) &&
|
|
311
|
+
})) && (undefined === input.noImplicitUseStrict || "boolean" === typeof input.noImplicitUseStrict || $guard(exceptionable, {
|
|
312
312
|
path: path + ".noImplicitUseStrict",
|
|
313
313
|
expected: "(boolean | undefined)",
|
|
314
314
|
value: input.noImplicitUseStrict
|
|
315
|
-
})) &&
|
|
315
|
+
})) && (undefined === input.noPropertyAccessFromIndexSignature || "boolean" === typeof input.noPropertyAccessFromIndexSignature || $guard(exceptionable, {
|
|
316
316
|
path: path + ".noPropertyAccessFromIndexSignature",
|
|
317
317
|
expected: "(boolean | undefined)",
|
|
318
318
|
value: input.noPropertyAccessFromIndexSignature
|
|
319
|
-
})) &&
|
|
319
|
+
})) && (undefined === input.assumeChangesOnlyAffectDirectDependencies || "boolean" === typeof input.assumeChangesOnlyAffectDirectDependencies || $guard(exceptionable, {
|
|
320
320
|
path: path + ".assumeChangesOnlyAffectDirectDependencies",
|
|
321
321
|
expected: "(boolean | undefined)",
|
|
322
322
|
value: input.assumeChangesOnlyAffectDirectDependencies
|
|
323
|
-
})) &&
|
|
323
|
+
})) && (undefined === input.noLib || "boolean" === typeof input.noLib || $guard(exceptionable, {
|
|
324
324
|
path: path + ".noLib",
|
|
325
325
|
expected: "(boolean | undefined)",
|
|
326
326
|
value: input.noLib
|
|
327
|
-
})) &&
|
|
327
|
+
})) && (undefined === input.noResolve || "boolean" === typeof input.noResolve || $guard(exceptionable, {
|
|
328
328
|
path: path + ".noResolve",
|
|
329
329
|
expected: "(boolean | undefined)",
|
|
330
330
|
value: input.noResolve
|
|
331
|
-
})) &&
|
|
331
|
+
})) && (undefined === input.noUncheckedIndexedAccess || "boolean" === typeof input.noUncheckedIndexedAccess || $guard(exceptionable, {
|
|
332
332
|
path: path + ".noUncheckedIndexedAccess",
|
|
333
333
|
expected: "(boolean | undefined)",
|
|
334
334
|
value: input.noUncheckedIndexedAccess
|
|
335
|
-
})) &&
|
|
335
|
+
})) && (undefined === input.out || "string" === typeof input.out || $guard(exceptionable, {
|
|
336
336
|
path: path + ".out",
|
|
337
337
|
expected: "(string | undefined)",
|
|
338
338
|
value: input.out
|
|
339
|
-
})) &&
|
|
339
|
+
})) && (undefined === input.outDir || "string" === typeof input.outDir || $guard(exceptionable, {
|
|
340
340
|
path: path + ".outDir",
|
|
341
341
|
expected: "(string | undefined)",
|
|
342
342
|
value: input.outDir
|
|
343
|
-
})) &&
|
|
343
|
+
})) && (undefined === input.outFile || "string" === typeof input.outFile || $guard(exceptionable, {
|
|
344
344
|
path: path + ".outFile",
|
|
345
345
|
expected: "(string | undefined)",
|
|
346
346
|
value: input.outFile
|
|
347
|
-
})) &&
|
|
347
|
+
})) && (undefined === input.paths || ("object" === typeof input.paths && null !== input.paths || $guard(exceptionable, {
|
|
348
348
|
path: path + ".paths",
|
|
349
349
|
expected: "(Resolve<ts.MapLike<Array<string>>> | undefined)",
|
|
350
350
|
value: input.paths
|
|
351
|
-
})),
|
|
352
|
-
path: path + ".paths",
|
|
353
|
-
expected: "(Resolve<ts.MapLike<Array<string>>> | undefined)",
|
|
354
|
-
value: input.paths
|
|
355
|
-
})) && $predicate(undefined === input.preserveConstEnums || "boolean" === typeof input.preserveConstEnums, exceptionable, () => ({
|
|
351
|
+
})) && $ao3(input.paths, path + ".paths", true && exceptionable)) && (undefined === input.preserveConstEnums || "boolean" === typeof input.preserveConstEnums || $guard(exceptionable, {
|
|
356
352
|
path: path + ".preserveConstEnums",
|
|
357
353
|
expected: "(boolean | undefined)",
|
|
358
354
|
value: input.preserveConstEnums
|
|
359
|
-
})) &&
|
|
355
|
+
})) && (undefined === input.noImplicitOverride || "boolean" === typeof input.noImplicitOverride || $guard(exceptionable, {
|
|
360
356
|
path: path + ".noImplicitOverride",
|
|
361
357
|
expected: "(boolean | undefined)",
|
|
362
358
|
value: input.noImplicitOverride
|
|
363
|
-
})) &&
|
|
359
|
+
})) && (undefined === input.preserveSymlinks || "boolean" === typeof input.preserveSymlinks || $guard(exceptionable, {
|
|
364
360
|
path: path + ".preserveSymlinks",
|
|
365
361
|
expected: "(boolean | undefined)",
|
|
366
362
|
value: input.preserveSymlinks
|
|
367
|
-
})) &&
|
|
363
|
+
})) && (undefined === input.preserveValueImports || "boolean" === typeof input.preserveValueImports || $guard(exceptionable, {
|
|
368
364
|
path: path + ".preserveValueImports",
|
|
369
365
|
expected: "(boolean | undefined)",
|
|
370
366
|
value: input.preserveValueImports
|
|
371
|
-
})) &&
|
|
367
|
+
})) && (undefined === input.project || "string" === typeof input.project || $guard(exceptionable, {
|
|
372
368
|
path: path + ".project",
|
|
373
369
|
expected: "(string | undefined)",
|
|
374
370
|
value: input.project
|
|
375
|
-
})) &&
|
|
371
|
+
})) && (undefined === input.reactNamespace || "string" === typeof input.reactNamespace || $guard(exceptionable, {
|
|
376
372
|
path: path + ".reactNamespace",
|
|
377
373
|
expected: "(string | undefined)",
|
|
378
374
|
value: input.reactNamespace
|
|
379
|
-
})) &&
|
|
375
|
+
})) && (undefined === input.jsxFactory || "string" === typeof input.jsxFactory || $guard(exceptionable, {
|
|
380
376
|
path: path + ".jsxFactory",
|
|
381
377
|
expected: "(string | undefined)",
|
|
382
378
|
value: input.jsxFactory
|
|
383
|
-
})) &&
|
|
379
|
+
})) && (undefined === input.jsxFragmentFactory || "string" === typeof input.jsxFragmentFactory || $guard(exceptionable, {
|
|
384
380
|
path: path + ".jsxFragmentFactory",
|
|
385
381
|
expected: "(string | undefined)",
|
|
386
382
|
value: input.jsxFragmentFactory
|
|
387
|
-
})) &&
|
|
383
|
+
})) && (undefined === input.jsxImportSource || "string" === typeof input.jsxImportSource || $guard(exceptionable, {
|
|
388
384
|
path: path + ".jsxImportSource",
|
|
389
385
|
expected: "(string | undefined)",
|
|
390
386
|
value: input.jsxImportSource
|
|
391
|
-
})) &&
|
|
387
|
+
})) && (undefined === input.composite || "boolean" === typeof input.composite || $guard(exceptionable, {
|
|
392
388
|
path: path + ".composite",
|
|
393
389
|
expected: "(boolean | undefined)",
|
|
394
390
|
value: input.composite
|
|
395
|
-
})) &&
|
|
391
|
+
})) && (undefined === input.incremental || "boolean" === typeof input.incremental || $guard(exceptionable, {
|
|
396
392
|
path: path + ".incremental",
|
|
397
393
|
expected: "(boolean | undefined)",
|
|
398
394
|
value: input.incremental
|
|
399
|
-
})) &&
|
|
395
|
+
})) && (undefined === input.tsBuildInfoFile || "string" === typeof input.tsBuildInfoFile || $guard(exceptionable, {
|
|
400
396
|
path: path + ".tsBuildInfoFile",
|
|
401
397
|
expected: "(string | undefined)",
|
|
402
398
|
value: input.tsBuildInfoFile
|
|
403
|
-
})) &&
|
|
399
|
+
})) && (undefined === input.removeComments || "boolean" === typeof input.removeComments || $guard(exceptionable, {
|
|
404
400
|
path: path + ".removeComments",
|
|
405
401
|
expected: "(boolean | undefined)",
|
|
406
402
|
value: input.removeComments
|
|
407
|
-
})) &&
|
|
403
|
+
})) && (undefined === input.rootDir || "string" === typeof input.rootDir || $guard(exceptionable, {
|
|
408
404
|
path: path + ".rootDir",
|
|
409
405
|
expected: "(string | undefined)",
|
|
410
406
|
value: input.rootDir
|
|
411
|
-
})) &&
|
|
412
|
-
path: path + ".rootDirs[" + index6 + "]",
|
|
413
|
-
expected: "string",
|
|
414
|
-
value: elem
|
|
415
|
-
}))), exceptionable, () => ({
|
|
407
|
+
})) && (undefined === input.rootDirs || (Array.isArray(input.rootDirs) || $guard(exceptionable, {
|
|
416
408
|
path: path + ".rootDirs",
|
|
417
409
|
expected: "(Array<string> | undefined)",
|
|
418
410
|
value: input.rootDirs
|
|
419
|
-
})) &&
|
|
411
|
+
})) && input.rootDirs.every((elem, index6) => "string" === typeof elem || $guard(exceptionable, {
|
|
412
|
+
path: path + ".rootDirs[" + index6 + "]",
|
|
413
|
+
expected: "string",
|
|
414
|
+
value: elem
|
|
415
|
+
}))) && (undefined === input.skipLibCheck || "boolean" === typeof input.skipLibCheck || $guard(exceptionable, {
|
|
420
416
|
path: path + ".skipLibCheck",
|
|
421
417
|
expected: "(boolean | undefined)",
|
|
422
418
|
value: input.skipLibCheck
|
|
423
|
-
})) &&
|
|
419
|
+
})) && (undefined === input.skipDefaultLibCheck || "boolean" === typeof input.skipDefaultLibCheck || $guard(exceptionable, {
|
|
424
420
|
path: path + ".skipDefaultLibCheck",
|
|
425
421
|
expected: "(boolean | undefined)",
|
|
426
422
|
value: input.skipDefaultLibCheck
|
|
427
|
-
})) &&
|
|
423
|
+
})) && (undefined === input.sourceMap || "boolean" === typeof input.sourceMap || $guard(exceptionable, {
|
|
428
424
|
path: path + ".sourceMap",
|
|
429
425
|
expected: "(boolean | undefined)",
|
|
430
426
|
value: input.sourceMap
|
|
431
|
-
})) &&
|
|
427
|
+
})) && (undefined === input.sourceRoot || "string" === typeof input.sourceRoot || $guard(exceptionable, {
|
|
432
428
|
path: path + ".sourceRoot",
|
|
433
429
|
expected: "(string | undefined)",
|
|
434
430
|
value: input.sourceRoot
|
|
435
|
-
})) &&
|
|
431
|
+
})) && (undefined === input.strict || "boolean" === typeof input.strict || $guard(exceptionable, {
|
|
436
432
|
path: path + ".strict",
|
|
437
433
|
expected: "(boolean | undefined)",
|
|
438
434
|
value: input.strict
|
|
439
|
-
})) &&
|
|
435
|
+
})) && (undefined === input.strictFunctionTypes || "boolean" === typeof input.strictFunctionTypes || $guard(exceptionable, {
|
|
440
436
|
path: path + ".strictFunctionTypes",
|
|
441
437
|
expected: "(boolean | undefined)",
|
|
442
438
|
value: input.strictFunctionTypes
|
|
443
|
-
})) &&
|
|
439
|
+
})) && (undefined === input.strictBindCallApply || "boolean" === typeof input.strictBindCallApply || $guard(exceptionable, {
|
|
444
440
|
path: path + ".strictBindCallApply",
|
|
445
441
|
expected: "(boolean | undefined)",
|
|
446
442
|
value: input.strictBindCallApply
|
|
447
|
-
})) &&
|
|
443
|
+
})) && (undefined === input.strictNullChecks || "boolean" === typeof input.strictNullChecks || $guard(exceptionable, {
|
|
448
444
|
path: path + ".strictNullChecks",
|
|
449
445
|
expected: "(boolean | undefined)",
|
|
450
446
|
value: input.strictNullChecks
|
|
451
|
-
})) &&
|
|
447
|
+
})) && (undefined === input.strictPropertyInitialization || "boolean" === typeof input.strictPropertyInitialization || $guard(exceptionable, {
|
|
452
448
|
path: path + ".strictPropertyInitialization",
|
|
453
449
|
expected: "(boolean | undefined)",
|
|
454
450
|
value: input.strictPropertyInitialization
|
|
455
|
-
})) &&
|
|
451
|
+
})) && (undefined === input.stripInternal || "boolean" === typeof input.stripInternal || $guard(exceptionable, {
|
|
456
452
|
path: path + ".stripInternal",
|
|
457
453
|
expected: "(boolean | undefined)",
|
|
458
454
|
value: input.stripInternal
|
|
459
|
-
})) &&
|
|
455
|
+
})) && (undefined === input.suppressExcessPropertyErrors || "boolean" === typeof input.suppressExcessPropertyErrors || $guard(exceptionable, {
|
|
460
456
|
path: path + ".suppressExcessPropertyErrors",
|
|
461
457
|
expected: "(boolean | undefined)",
|
|
462
458
|
value: input.suppressExcessPropertyErrors
|
|
463
|
-
})) &&
|
|
459
|
+
})) && (undefined === input.suppressImplicitAnyIndexErrors || "boolean" === typeof input.suppressImplicitAnyIndexErrors || $guard(exceptionable, {
|
|
464
460
|
path: path + ".suppressImplicitAnyIndexErrors",
|
|
465
461
|
expected: "(boolean | undefined)",
|
|
466
462
|
value: input.suppressImplicitAnyIndexErrors
|
|
467
|
-
})) && true &&
|
|
463
|
+
})) && true && (undefined === input.traceResolution || "boolean" === typeof input.traceResolution || $guard(exceptionable, {
|
|
468
464
|
path: path + ".traceResolution",
|
|
469
465
|
expected: "(boolean | undefined)",
|
|
470
466
|
value: input.traceResolution
|
|
471
|
-
})) &&
|
|
467
|
+
})) && (undefined === input.useUnknownInCatchVariables || "boolean" === typeof input.useUnknownInCatchVariables || $guard(exceptionable, {
|
|
472
468
|
path: path + ".useUnknownInCatchVariables",
|
|
473
469
|
expected: "(boolean | undefined)",
|
|
474
470
|
value: input.useUnknownInCatchVariables
|
|
475
|
-
})) &&
|
|
471
|
+
})) && (undefined === input.resolveJsonModule || "boolean" === typeof input.resolveJsonModule || $guard(exceptionable, {
|
|
476
472
|
path: path + ".resolveJsonModule",
|
|
477
473
|
expected: "(boolean | undefined)",
|
|
478
474
|
value: input.resolveJsonModule
|
|
479
|
-
})) &&
|
|
480
|
-
path: path + ".types[" + index7 + "]",
|
|
481
|
-
expected: "string",
|
|
482
|
-
value: elem
|
|
483
|
-
}))), exceptionable, () => ({
|
|
475
|
+
})) && (undefined === input.types || (Array.isArray(input.types) || $guard(exceptionable, {
|
|
484
476
|
path: path + ".types",
|
|
485
477
|
expected: "(Array<string> | undefined)",
|
|
486
478
|
value: input.types
|
|
487
|
-
})) &&
|
|
488
|
-
path: path + ".
|
|
479
|
+
})) && input.types.every((elem, index7) => "string" === typeof elem || $guard(exceptionable, {
|
|
480
|
+
path: path + ".types[" + index7 + "]",
|
|
489
481
|
expected: "string",
|
|
490
482
|
value: elem
|
|
491
|
-
})))
|
|
483
|
+
}))) && (undefined === input.typeRoots || (Array.isArray(input.typeRoots) || $guard(exceptionable, {
|
|
492
484
|
path: path + ".typeRoots",
|
|
493
485
|
expected: "(Array<string> | undefined)",
|
|
494
486
|
value: input.typeRoots
|
|
495
|
-
})) &&
|
|
487
|
+
})) && input.typeRoots.every((elem, index8) => "string" === typeof elem || $guard(exceptionable, {
|
|
488
|
+
path: path + ".typeRoots[" + index8 + "]",
|
|
489
|
+
expected: "string",
|
|
490
|
+
value: elem
|
|
491
|
+
}))) && (undefined === input.esModuleInterop || "boolean" === typeof input.esModuleInterop || $guard(exceptionable, {
|
|
496
492
|
path: path + ".esModuleInterop",
|
|
497
493
|
expected: "(boolean | undefined)",
|
|
498
494
|
value: input.esModuleInterop
|
|
499
|
-
})) &&
|
|
495
|
+
})) && (undefined === input.useDefineForClassFields || "boolean" === typeof input.useDefineForClassFields || $guard(exceptionable, {
|
|
500
496
|
path: path + ".useDefineForClassFields",
|
|
501
497
|
expected: "(boolean | undefined)",
|
|
502
498
|
value: input.useDefineForClassFields
|
|
503
|
-
})) && (false === exceptionable || Object.entries(input).every(([key, value]) =>
|
|
499
|
+
})) && (false === exceptionable || Object.entries(input).every(([key, value]) => {
|
|
504
500
|
if (undefined === value)
|
|
505
501
|
return true;
|
|
506
502
|
if (RegExp(/(.*)/).test(key))
|
|
507
503
|
return true;
|
|
508
504
|
return true;
|
|
509
|
-
})
|
|
510
|
-
|
|
511
|
-
expected: "undefined",
|
|
512
|
-
value: value
|
|
513
|
-
})))),
|
|
514
|
-
(input, path, exceptionable) => false === exceptionable || Object.entries(input).every(([key, value]) => $predicate((() => {
|
|
505
|
+
}));
|
|
506
|
+
const $ao3 = (input, path, exceptionable) => false === exceptionable || Object.entries(input).every(([key, value]) => {
|
|
515
507
|
if (undefined === value)
|
|
516
508
|
return true;
|
|
517
509
|
if (RegExp(/(.*)/).test(key))
|
|
518
|
-
return
|
|
519
|
-
path: path + $join(key) + "[" + index9 + "]",
|
|
520
|
-
expected: "string",
|
|
521
|
-
value: elem
|
|
522
|
-
}))), exceptionable, () => ({
|
|
510
|
+
return (Array.isArray(value) || $guard(exceptionable, {
|
|
523
511
|
path: path + $join(key),
|
|
524
512
|
expected: "Array<string>",
|
|
525
513
|
value: value
|
|
514
|
+
})) && value.every((elem, index9) => "string" === typeof elem || $guard(exceptionable, {
|
|
515
|
+
path: path + $join(key) + "[" + index9 + "]",
|
|
516
|
+
expected: "string",
|
|
517
|
+
value: elem
|
|
526
518
|
}));
|
|
527
519
|
return true;
|
|
528
|
-
})
|
|
529
|
-
|
|
530
|
-
expected: "undefined",
|
|
531
|
-
value: value
|
|
532
|
-
}))),
|
|
533
|
-
(input, path, exceptionable) => $predicate("string" === typeof input.output, exceptionable, () => ({
|
|
520
|
+
});
|
|
521
|
+
const $ao4 = (input, path, exceptionable) => "string" === typeof input.output || $guard(exceptionable, {
|
|
534
522
|
path: path + ".output",
|
|
535
523
|
expected: "string",
|
|
536
524
|
value: input.output
|
|
537
|
-
})
|
|
538
|
-
|
|
539
|
-
|
|
540
|
-
|
|
541
|
-
|
|
542
|
-
|
|
543
|
-
})
|
|
544
|
-
|
|
545
|
-
|
|
546
|
-
value: input
|
|
547
|
-
}));
|
|
548
|
-
})(input); return input; })(nestia_fetcher_1.Primitive.clone(config));
|
|
525
|
+
});
|
|
526
|
+
return ("object" === typeof input && null !== input || $guard(true, {
|
|
527
|
+
path: path + "",
|
|
528
|
+
expected: "Resolve<__type>",
|
|
529
|
+
value: input
|
|
530
|
+
})) && $ao0(input, path + "", true);
|
|
531
|
+
})(input, "$input", true);
|
|
532
|
+
return input;
|
|
533
|
+
})(nestia_fetcher_1.Primitive.clone(config));
|
|
549
534
|
}));
|
|
550
535
|
})(NestiaConfig = exports.NestiaConfig || (exports.NestiaConfig = {}));
|
|
551
536
|
//# sourceMappingURL=NestiaConfig.js.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"NestiaConfig.js","sourceRoot":"","sources":["../../../src/executable/internal/NestiaConfig.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,4CAAoB;AACpB,gDAAwB;AACxB,gDAAkC;AAClC,mDAA2C;AAC3C,qDAAkD;AAClD,qDAA6C;AAI7C,IAAiB,YAAY,CA0B5B;AA1BD,WAAiB,YAAY;IACzB,SAAgB,GAAG;QACf,OAAO,SAAS,CAAC,GAAG,EAAE,CAAC;IAC3B,CAAC;IAFe,gBAAG,MAElB,CAAA;IAED,MAAM,SAAS,GAAG,IAAI,qBAAS,CAAC,GAAS,EAAE;QACvC,IAAI,YAAE,CAAC,UAAU,CAAC,kBAAkB,CAAC,KAAK,KAAK;YAAE,OAAO,IAAI,CAAC;QAE7D,MAAM,CAAC,QAAQ,CAAC;YACZ,IAAI,EAAE,KAAK;YACX,eAAe,EAAE;gBACb,MAAM,EAAE,UAAU;gBAClB,MAAM,EAAE,IAAI;aACf;SACJ,CAAC,CAAC;QAEH,MAAM,MAAM,GACR,wDAAa,cAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,GAAC,CAAC;QACnD,IAAI,OAAO,MAAM,KAAK,QAAQ;YAC1B,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;QAExE,MAAM,MAAM,GACR,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC;QAEjE
|
|
1
|
+
{"version":3,"file":"NestiaConfig.js","sourceRoot":"","sources":["../../../src/executable/internal/NestiaConfig.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,4CAAoB;AACpB,gDAAwB;AACxB,gDAAkC;AAClC,mDAA2C;AAC3C,qDAAkD;AAClD,qDAA6C;AAI7C,IAAiB,YAAY,CA0B5B;AA1BD,WAAiB,YAAY;IACzB,SAAgB,GAAG;QACf,OAAO,SAAS,CAAC,GAAG,EAAE,CAAC;IAC3B,CAAC;IAFe,gBAAG,MAElB,CAAA;IAED,MAAM,SAAS,GAAG,IAAI,qBAAS,CAAC,GAAS,EAAE;QACvC,IAAI,YAAE,CAAC,UAAU,CAAC,kBAAkB,CAAC,KAAK,KAAK;YAAE,OAAO,IAAI,CAAC;QAE7D,MAAM,CAAC,QAAQ,CAAC;YACZ,IAAI,EAAE,KAAK;YACX,eAAe,EAAE;gBACb,MAAM,EAAE,UAAU;gBAClB,MAAM,EAAE,IAAI;aACf;SACJ,CAAC,CAAC;QAEH,MAAM,MAAM,GACR,wDAAa,cAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,GAAC,CAAC;QACnD,IAAI,OAAO,MAAM,KAAK,QAAQ;YAC1B,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;QAExE,MAAM,MAAM,GACR,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC;QAEjE;2BAAO,4BAAU;0BAAV,4BAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAAC,0BAAS,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;IAC/C,CAAC,CAAA,CAAC,CAAC;AACP,CAAC,EA1BgB,YAAY,GAAZ,oBAAY,KAAZ,oBAAY,QA0B5B"}
|
package/lib/executable/nestia.js
CHANGED
|
File without changes
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "nestia",
|
|
3
|
-
"version": "3.1.4
|
|
3
|
+
"version": "3.1.4",
|
|
4
4
|
"description": "Automatic SDK and Document generator for the NestJS",
|
|
5
5
|
"main": "lib/index.js",
|
|
6
6
|
"typings": "lib/index.d.ts",
|
|
@@ -42,8 +42,8 @@
|
|
|
42
42
|
"tgrid": "^0.8.7",
|
|
43
43
|
"tsconfck": "^2.0.1",
|
|
44
44
|
"tsconfig-paths": "^4.0.0",
|
|
45
|
-
"tstl": "^2.5.
|
|
46
|
-
"typescript-json": "^3.3.
|
|
45
|
+
"tstl": "^2.5.13",
|
|
46
|
+
"typescript-json": "^3.3.23"
|
|
47
47
|
},
|
|
48
48
|
"devDependencies": {
|
|
49
49
|
"@types/cli": "^0.11.19",
|
|
@@ -55,13 +55,13 @@
|
|
|
55
55
|
"@typescript-eslint/eslint-plugin": "^5.26.0",
|
|
56
56
|
"@typescript-eslint/parser": "^5.26.0",
|
|
57
57
|
"eslint": "^8.16.0",
|
|
58
|
-
"nestia-helper": "^3.
|
|
58
|
+
"nestia-helper": "^3.1.10",
|
|
59
59
|
"prettier": "^2.6.2",
|
|
60
60
|
"rimraf": "^3.0.2",
|
|
61
61
|
"ts-node": "10.8.x",
|
|
62
62
|
"ttypescript": "^1.5.13",
|
|
63
63
|
"typescript": "^4.8.4",
|
|
64
|
-
"typescript-transform-paths": "
|
|
64
|
+
"typescript-transform-paths": "3.3.1",
|
|
65
65
|
"uuid": "^8.3.2"
|
|
66
66
|
},
|
|
67
67
|
"files": [
|