@voxgig/apidef 8.7.1 → 8.9.0

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 (17) hide show
  1. package/dist/guide/heuristic01.js +14 -0
  2. package/dist/guide/heuristic01.js.map +1 -1
  3. package/dist/transform/field.js +17 -0
  4. package/dist/transform/field.js.map +1 -1
  5. package/dist/transform/flowstep.js +6 -1
  6. package/dist/transform/flowstep.js.map +1 -1
  7. package/dist/transform.d.ts +18 -42
  8. package/dist/tsconfig.tsbuildinfo +1 -1
  9. package/dist/types.d.ts +231 -275
  10. package/dist/utility.d.ts +2 -1
  11. package/dist/utility.js +48 -0
  12. package/dist/utility.js.map +1 -1
  13. package/package.json +2 -2
  14. package/src/guide/heuristic01.ts +16 -0
  15. package/src/transform/field.ts +18 -0
  16. package/src/transform/flowstep.ts +6 -1
  17. package/src/utility.ts +56 -1
package/dist/types.d.ts CHANGED
@@ -30,7 +30,7 @@ type ApiDefAuthOption = {
30
30
  prefix?: string;
31
31
  };
32
32
  declare const ControlShape: {
33
- <V>(root?: V | undefined, ctx?: import("shape").Context): V & {
33
+ <V>(root?: V | undefined, ctx?: import("shape").Context): (0 extends 1 & V ? true : false) extends true ? {
34
34
  step: {
35
35
  parse: boolean;
36
36
  guide: boolean;
@@ -38,8 +38,7 @@ declare const ControlShape: {
38
38
  builders: boolean;
39
39
  generate: boolean;
40
40
  };
41
- };
42
- valid: <V>(root?: V | undefined, ctx?: import("shape").Context) => root is V & {
41
+ } : V extends object ? Omit<V, "step"> & {
43
42
  step: {
44
43
  parse: boolean;
45
44
  guide: boolean;
@@ -47,47 +46,16 @@ declare const ControlShape: {
47
46
  builders: boolean;
48
47
  generate: boolean;
49
48
  };
50
- };
51
- match: (root?: any, ctx?: import("shape").Context) => boolean;
52
- error: (root?: any, ctx?: import("shape").Context) => {
53
- shape: boolean;
54
- code: string;
55
- gname: string;
56
- props: ({
57
- path: string;
58
- type: string;
59
- value: any;
60
- }[]);
61
- desc: () => ({
62
- name: string;
63
- code: string;
64
- err: {
65
- key: string;
66
- type: string;
67
- node: import("shape").Node<any>;
68
- value: any;
69
- path: string;
70
- pathArr: (string | number)[];
71
- why: string;
72
- check: string;
73
- args: Record<string, any>;
74
- mark: number;
75
- text: string;
76
- use: any;
77
- }[];
78
- ctx: any;
79
- });
80
- toJSON(): /*elided*/ any & {
81
- err: any;
82
- name: string;
83
- message: string;
49
+ } : {
50
+ step: {
51
+ parse: boolean;
52
+ guide: boolean;
53
+ transformers: boolean;
54
+ builders: boolean;
55
+ generate: boolean;
84
56
  };
85
- name: string;
86
- message: string;
87
- stack?: string;
88
- }[];
89
- spec: () => any;
90
- node: () => import("shape").Node<{
57
+ };
58
+ valid: <V>(root?: V | undefined, ctx?: import("shape").Context) => root is V & {
91
59
  step: {
92
60
  parse: boolean;
93
61
  guide: boolean;
@@ -95,9 +63,23 @@ declare const ControlShape: {
95
63
  builders: boolean;
96
64
  generate: boolean;
97
65
  };
66
+ };
67
+ match: (root?: any, ctx?: import("shape").Context) => boolean;
68
+ error: (root?: any, ctx?: import("shape").Context) => import("shape").ErrDesc[];
69
+ spec: () => any;
70
+ node: () => import("shape").Node<{
71
+ readonly step: {
72
+ readonly parse: true;
73
+ readonly guide: true;
74
+ readonly transformers: true;
75
+ readonly builders: true;
76
+ readonly generate: true;
77
+ };
98
78
  }>;
99
79
  stringify: (...rest: any[]) => string;
100
80
  jsonify: () => any;
81
+ jsonSchema: () => any;
82
+ json: () => any;
101
83
  toString: (this: any) => string;
102
84
  shape: {
103
85
  shape$: symbol;
@@ -105,7 +87,7 @@ declare const ControlShape: {
105
87
  };
106
88
  };
107
89
  declare const OpenControlShape: {
108
- <V>(root?: V | undefined, ctx?: import("shape").Context): V & {
90
+ <V>(root?: V | undefined, ctx?: import("shape").Context): (0 extends 1 & V ? true : false) extends true ? {
109
91
  step: {
110
92
  parse: boolean;
111
93
  guide: boolean;
@@ -113,8 +95,7 @@ declare const OpenControlShape: {
113
95
  builders: boolean;
114
96
  generate: boolean;
115
97
  };
116
- };
117
- valid: <V>(root?: V | undefined, ctx?: import("shape").Context) => root is V & {
98
+ } : V extends object ? Omit<V, "step"> & {
118
99
  step: {
119
100
  parse: boolean;
120
101
  guide: boolean;
@@ -122,47 +103,16 @@ declare const OpenControlShape: {
122
103
  builders: boolean;
123
104
  generate: boolean;
124
105
  };
125
- };
126
- match: (root?: any, ctx?: import("shape").Context) => boolean;
127
- error: (root?: any, ctx?: import("shape").Context) => {
128
- shape: boolean;
129
- code: string;
130
- gname: string;
131
- props: ({
132
- path: string;
133
- type: string;
134
- value: any;
135
- }[]);
136
- desc: () => ({
137
- name: string;
138
- code: string;
139
- err: {
140
- key: string;
141
- type: string;
142
- node: import("shape").Node<any>;
143
- value: any;
144
- path: string;
145
- pathArr: (string | number)[];
146
- why: string;
147
- check: string;
148
- args: Record<string, any>;
149
- mark: number;
150
- text: string;
151
- use: any;
152
- }[];
153
- ctx: any;
154
- });
155
- toJSON(): /*elided*/ any & {
156
- err: any;
157
- name: string;
158
- message: string;
106
+ } : {
107
+ step: {
108
+ parse: boolean;
109
+ guide: boolean;
110
+ transformers: boolean;
111
+ builders: boolean;
112
+ generate: boolean;
159
113
  };
160
- name: string;
161
- message: string;
162
- stack?: string;
163
- }[];
164
- spec: () => any;
165
- node: () => import("shape").Node<{
114
+ };
115
+ valid: <V>(root?: V | undefined, ctx?: import("shape").Context) => root is V & {
166
116
  step: {
167
117
  parse: boolean;
168
118
  guide: boolean;
@@ -170,9 +120,23 @@ declare const OpenControlShape: {
170
120
  builders: boolean;
171
121
  generate: boolean;
172
122
  };
173
- }>;
123
+ };
124
+ match: (root?: any, ctx?: import("shape").Context) => boolean;
125
+ error: (root?: any, ctx?: import("shape").Context) => import("shape").ErrDesc[];
126
+ spec: () => any;
127
+ node: () => import("shape").Node<import("shape").Node<{
128
+ readonly step: {
129
+ readonly parse: true;
130
+ readonly guide: true;
131
+ readonly transformers: true;
132
+ readonly builders: true;
133
+ readonly generate: true;
134
+ };
135
+ }>>;
174
136
  stringify: (...rest: any[]) => string;
175
137
  jsonify: () => any;
138
+ jsonSchema: () => any;
139
+ json: () => any;
176
140
  toString: (this: any) => string;
177
141
  shape: {
178
142
  shape$: symbol;
@@ -181,7 +145,7 @@ declare const OpenControlShape: {
181
145
  };
182
146
  type Control = ReturnType<typeof ControlShape>;
183
147
  declare const ModelShape: {
184
- <V>(root?: V | undefined, ctx?: import("shape").Context): V & {
148
+ <V>(root?: V | undefined, ctx?: import("shape").Context): (0 extends 1 & V ? true : false) extends true ? {
185
149
  name: string;
186
150
  def: string;
187
151
  main: {
@@ -195,10 +159,9 @@ declare const ModelShape: {
195
159
  plurals: {};
196
160
  };
197
161
  };
198
- };
199
- valid: <V>(root?: V | undefined, ctx?: import("shape").Context) => root is V & {
200
- name: StringConstructor;
201
- def: StringConstructor;
162
+ } : V extends object ? Omit<V, "def" | "main" | "name"> & {
163
+ name: string;
164
+ def: string;
202
165
  main: {
203
166
  kit: {};
204
167
  def: {};
@@ -210,49 +173,24 @@ declare const ModelShape: {
210
173
  plurals: {};
211
174
  };
212
175
  };
213
- };
214
- match: (root?: any, ctx?: import("shape").Context) => boolean;
215
- error: (root?: any, ctx?: import("shape").Context) => {
216
- shape: boolean;
217
- code: string;
218
- gname: string;
219
- props: ({
220
- path: string;
221
- type: string;
222
- value: any;
223
- }[]);
224
- desc: () => ({
225
- name: string;
226
- code: string;
227
- err: {
228
- key: string;
229
- type: string;
230
- node: import("shape").Node<any>;
231
- value: any;
232
- path: string;
233
- pathArr: (string | number)[];
234
- why: string;
235
- check: string;
236
- args: Record<string, any>;
237
- mark: number;
238
- text: string;
239
- use: any;
240
- }[];
241
- ctx: any;
242
- });
243
- toJSON(): /*elided*/ any & {
244
- err: any;
245
- name: string;
246
- message: string;
176
+ } : {
177
+ name: string;
178
+ def: string;
179
+ main: {
180
+ kit: {};
181
+ def: {};
182
+ api: {
183
+ guide: {};
184
+ entity: {};
185
+ };
186
+ custom: {
187
+ plurals: {};
188
+ };
247
189
  };
190
+ };
191
+ valid: <V>(root?: V | undefined, ctx?: import("shape").Context) => root is V & {
248
192
  name: string;
249
- message: string;
250
- stack?: string;
251
- }[];
252
- spec: () => any;
253
- node: () => import("shape").Node<{
254
- name: StringConstructor;
255
- def: StringConstructor;
193
+ def: string;
256
194
  main: {
257
195
  kit: {};
258
196
  def: {};
@@ -264,9 +202,29 @@ declare const ModelShape: {
264
202
  plurals: {};
265
203
  };
266
204
  };
205
+ };
206
+ match: (root?: any, ctx?: import("shape").Context) => boolean;
207
+ error: (root?: any, ctx?: import("shape").Context) => import("shape").ErrDesc[];
208
+ spec: () => any;
209
+ node: () => import("shape").Node<{
210
+ readonly name: StringConstructor;
211
+ readonly def: StringConstructor;
212
+ readonly main: {
213
+ readonly kit: {};
214
+ readonly def: {};
215
+ readonly api: {
216
+ guide: {};
217
+ entity: {};
218
+ };
219
+ readonly custom: {
220
+ plurals: {};
221
+ };
222
+ };
267
223
  }>;
268
224
  stringify: (...rest: any[]) => string;
269
225
  jsonify: () => any;
226
+ jsonSchema: () => any;
227
+ json: () => any;
270
228
  toString: (this: any) => string;
271
229
  shape: {
272
230
  shape$: symbol;
@@ -274,7 +232,7 @@ declare const ModelShape: {
274
232
  };
275
233
  };
276
234
  declare const OpenModelShape: {
277
- <V>(root?: V | undefined, ctx?: import("shape").Context): V & {
235
+ <V>(root?: V | undefined, ctx?: import("shape").Context): (0 extends 1 & V ? true : false) extends true ? {
278
236
  name: string;
279
237
  def: string;
280
238
  main: {
@@ -288,10 +246,9 @@ declare const OpenModelShape: {
288
246
  plurals: {};
289
247
  };
290
248
  };
291
- };
292
- valid: <V>(root?: V | undefined, ctx?: import("shape").Context) => root is V & {
293
- name: StringConstructor;
294
- def: StringConstructor;
249
+ } : V extends object ? Omit<V, "def" | "main" | "name"> & {
250
+ name: string;
251
+ def: string;
295
252
  main: {
296
253
  kit: {};
297
254
  def: {};
@@ -303,49 +260,24 @@ declare const OpenModelShape: {
303
260
  plurals: {};
304
261
  };
305
262
  };
306
- };
307
- match: (root?: any, ctx?: import("shape").Context) => boolean;
308
- error: (root?: any, ctx?: import("shape").Context) => {
309
- shape: boolean;
310
- code: string;
311
- gname: string;
312
- props: ({
313
- path: string;
314
- type: string;
315
- value: any;
316
- }[]);
317
- desc: () => ({
318
- name: string;
319
- code: string;
320
- err: {
321
- key: string;
322
- type: string;
323
- node: import("shape").Node<any>;
324
- value: any;
325
- path: string;
326
- pathArr: (string | number)[];
327
- why: string;
328
- check: string;
329
- args: Record<string, any>;
330
- mark: number;
331
- text: string;
332
- use: any;
333
- }[];
334
- ctx: any;
335
- });
336
- toJSON(): /*elided*/ any & {
337
- err: any;
338
- name: string;
339
- message: string;
263
+ } : {
264
+ name: string;
265
+ def: string;
266
+ main: {
267
+ kit: {};
268
+ def: {};
269
+ api: {
270
+ guide: {};
271
+ entity: {};
272
+ };
273
+ custom: {
274
+ plurals: {};
275
+ };
340
276
  };
277
+ };
278
+ valid: <V>(root?: V | undefined, ctx?: import("shape").Context) => root is V & {
341
279
  name: string;
342
- message: string;
343
- stack?: string;
344
- }[];
345
- spec: () => any;
346
- node: () => import("shape").Node<{
347
- name: StringConstructor;
348
- def: StringConstructor;
280
+ def: string;
349
281
  main: {
350
282
  kit: {};
351
283
  def: {};
@@ -357,9 +289,29 @@ declare const OpenModelShape: {
357
289
  plurals: {};
358
290
  };
359
291
  };
360
- }>;
292
+ };
293
+ match: (root?: any, ctx?: import("shape").Context) => boolean;
294
+ error: (root?: any, ctx?: import("shape").Context) => import("shape").ErrDesc[];
295
+ spec: () => any;
296
+ node: () => import("shape").Node<import("shape").Node<{
297
+ readonly name: StringConstructor;
298
+ readonly def: StringConstructor;
299
+ readonly main: {
300
+ readonly kit: {};
301
+ readonly def: {};
302
+ readonly api: {
303
+ guide: {};
304
+ entity: {};
305
+ };
306
+ readonly custom: {
307
+ plurals: {};
308
+ };
309
+ };
310
+ }>>;
361
311
  stringify: (...rest: any[]) => string;
362
312
  jsonify: () => any;
313
+ jsonSchema: () => any;
314
+ json: () => any;
363
315
  toString: (this: any) => string;
364
316
  shape: {
365
317
  shape$: symbol;
@@ -368,13 +320,13 @@ declare const OpenModelShape: {
368
320
  };
369
321
  type Model = ReturnType<typeof ModelShape>;
370
322
  declare const BuildShape: {
371
- <V>(root?: V | undefined, ctx?: import("shape").Context): V & {
323
+ <V>(root?: V | undefined, ctx?: import("shape").Context): (0 extends 1 & V ? true : false) extends true ? {
372
324
  spec: {
373
325
  base: string;
374
326
  path: string;
375
327
  debug: string;
376
328
  use: {};
377
- res: never[];
329
+ res: any[];
378
330
  require: string;
379
331
  log: {};
380
332
  fs: any;
@@ -386,17 +338,16 @@ declare const BuildShape: {
386
338
  rem: boolean;
387
339
  };
388
340
  };
389
- };
390
- valid: <V>(root?: V | undefined, ctx?: import("shape").Context) => root is V & {
341
+ } : V extends object ? Omit<V, "spec"> & {
391
342
  spec: {
392
343
  base: string;
393
344
  path: string;
394
345
  debug: string;
395
346
  use: {};
396
- res: never[];
347
+ res: any[];
397
348
  require: string;
398
349
  log: {};
399
- fs: import("shape").Node<unknown>;
350
+ fs: any;
400
351
  dryrun: boolean;
401
352
  buildargs: {};
402
353
  watch: {
@@ -405,56 +356,35 @@ declare const BuildShape: {
405
356
  rem: boolean;
406
357
  };
407
358
  };
408
- };
409
- match: (root?: any, ctx?: import("shape").Context) => boolean;
410
- error: (root?: any, ctx?: import("shape").Context) => {
411
- shape: boolean;
412
- code: string;
413
- gname: string;
414
- props: ({
359
+ } : {
360
+ spec: {
361
+ base: string;
415
362
  path: string;
416
- type: string;
417
- value: any;
418
- }[]);
419
- desc: () => ({
420
- name: string;
421
- code: string;
422
- err: {
423
- key: string;
424
- type: string;
425
- node: import("shape").Node<any>;
426
- value: any;
427
- path: string;
428
- pathArr: (string | number)[];
429
- why: string;
430
- check: string;
431
- args: Record<string, any>;
432
- mark: number;
433
- text: string;
434
- use: any;
435
- }[];
436
- ctx: any;
437
- });
438
- toJSON(): /*elided*/ any & {
439
- err: any;
440
- name: string;
441
- message: string;
363
+ debug: string;
364
+ use: {};
365
+ res: any[];
366
+ require: string;
367
+ log: {};
368
+ fs: any;
369
+ dryrun: boolean;
370
+ buildargs: {};
371
+ watch: {
372
+ mod: boolean;
373
+ add: boolean;
374
+ rem: boolean;
375
+ };
442
376
  };
443
- name: string;
444
- message: string;
445
- stack?: string;
446
- }[];
447
- spec: () => any;
448
- node: () => import("shape").Node<{
377
+ };
378
+ valid: <V>(root?: V | undefined, ctx?: import("shape").Context) => root is V & {
449
379
  spec: {
450
380
  base: string;
451
381
  path: string;
452
382
  debug: string;
453
383
  use: {};
454
- res: never[];
384
+ res: any[];
455
385
  require: string;
456
386
  log: {};
457
- fs: import("shape").Node<unknown>;
387
+ fs: any;
458
388
  dryrun: boolean;
459
389
  buildargs: {};
460
390
  watch: {
@@ -463,9 +393,33 @@ declare const BuildShape: {
463
393
  rem: boolean;
464
394
  };
465
395
  };
396
+ };
397
+ match: (root?: any, ctx?: import("shape").Context) => boolean;
398
+ error: (root?: any, ctx?: import("shape").Context) => import("shape").ErrDesc[];
399
+ spec: () => any;
400
+ node: () => import("shape").Node<{
401
+ readonly spec: {
402
+ readonly base: "";
403
+ readonly path: "";
404
+ readonly debug: "";
405
+ readonly use: {};
406
+ readonly res: readonly [];
407
+ readonly require: "";
408
+ readonly log: {};
409
+ readonly fs: import("shape").Node<any>;
410
+ readonly dryrun: false;
411
+ readonly buildargs: {};
412
+ readonly watch: {
413
+ readonly mod: true;
414
+ readonly add: true;
415
+ readonly rem: true;
416
+ };
417
+ };
466
418
  }>;
467
419
  stringify: (...rest: any[]) => string;
468
420
  jsonify: () => any;
421
+ jsonSchema: () => any;
422
+ json: () => any;
469
423
  toString: (this: any) => string;
470
424
  shape: {
471
425
  shape$: symbol;
@@ -473,13 +427,13 @@ declare const BuildShape: {
473
427
  };
474
428
  };
475
429
  declare const OpenBuildShape: {
476
- <V>(root?: V | undefined, ctx?: import("shape").Context): V & {
430
+ <V>(root?: V | undefined, ctx?: import("shape").Context): (0 extends 1 & V ? true : false) extends true ? {
477
431
  spec: {
478
432
  base: string;
479
433
  path: string;
480
434
  debug: string;
481
435
  use: {};
482
- res: never[];
436
+ res: any[];
483
437
  require: string;
484
438
  log: {};
485
439
  fs: any;
@@ -491,17 +445,16 @@ declare const OpenBuildShape: {
491
445
  rem: boolean;
492
446
  };
493
447
  };
494
- };
495
- valid: <V>(root?: V | undefined, ctx?: import("shape").Context) => root is V & {
448
+ } : V extends object ? Omit<V, "spec"> & {
496
449
  spec: {
497
450
  base: string;
498
451
  path: string;
499
452
  debug: string;
500
453
  use: {};
501
- res: never[];
454
+ res: any[];
502
455
  require: string;
503
456
  log: {};
504
- fs: import("shape").Node<unknown>;
457
+ fs: any;
505
458
  dryrun: boolean;
506
459
  buildargs: {};
507
460
  watch: {
@@ -510,56 +463,35 @@ declare const OpenBuildShape: {
510
463
  rem: boolean;
511
464
  };
512
465
  };
513
- };
514
- match: (root?: any, ctx?: import("shape").Context) => boolean;
515
- error: (root?: any, ctx?: import("shape").Context) => {
516
- shape: boolean;
517
- code: string;
518
- gname: string;
519
- props: ({
466
+ } : {
467
+ spec: {
468
+ base: string;
520
469
  path: string;
521
- type: string;
522
- value: any;
523
- }[]);
524
- desc: () => ({
525
- name: string;
526
- code: string;
527
- err: {
528
- key: string;
529
- type: string;
530
- node: import("shape").Node<any>;
531
- value: any;
532
- path: string;
533
- pathArr: (string | number)[];
534
- why: string;
535
- check: string;
536
- args: Record<string, any>;
537
- mark: number;
538
- text: string;
539
- use: any;
540
- }[];
541
- ctx: any;
542
- });
543
- toJSON(): /*elided*/ any & {
544
- err: any;
545
- name: string;
546
- message: string;
470
+ debug: string;
471
+ use: {};
472
+ res: any[];
473
+ require: string;
474
+ log: {};
475
+ fs: any;
476
+ dryrun: boolean;
477
+ buildargs: {};
478
+ watch: {
479
+ mod: boolean;
480
+ add: boolean;
481
+ rem: boolean;
482
+ };
547
483
  };
548
- name: string;
549
- message: string;
550
- stack?: string;
551
- }[];
552
- spec: () => any;
553
- node: () => import("shape").Node<{
484
+ };
485
+ valid: <V>(root?: V | undefined, ctx?: import("shape").Context) => root is V & {
554
486
  spec: {
555
487
  base: string;
556
488
  path: string;
557
489
  debug: string;
558
490
  use: {};
559
- res: never[];
491
+ res: any[];
560
492
  require: string;
561
493
  log: {};
562
- fs: import("shape").Node<unknown>;
494
+ fs: any;
563
495
  dryrun: boolean;
564
496
  buildargs: {};
565
497
  watch: {
@@ -568,9 +500,33 @@ declare const OpenBuildShape: {
568
500
  rem: boolean;
569
501
  };
570
502
  };
571
- }>;
503
+ };
504
+ match: (root?: any, ctx?: import("shape").Context) => boolean;
505
+ error: (root?: any, ctx?: import("shape").Context) => import("shape").ErrDesc[];
506
+ spec: () => any;
507
+ node: () => import("shape").Node<import("shape").Node<{
508
+ readonly spec: {
509
+ readonly base: "";
510
+ readonly path: "";
511
+ readonly debug: "";
512
+ readonly use: {};
513
+ readonly res: readonly [];
514
+ readonly require: "";
515
+ readonly log: {};
516
+ readonly fs: import("shape").Node<any>;
517
+ readonly dryrun: false;
518
+ readonly buildargs: {};
519
+ readonly watch: {
520
+ readonly mod: true;
521
+ readonly add: true;
522
+ readonly rem: true;
523
+ };
524
+ };
525
+ }>>;
572
526
  stringify: (...rest: any[]) => string;
573
527
  jsonify: () => any;
528
+ jsonSchema: () => any;
529
+ json: () => any;
574
530
  toString: (this: any) => string;
575
531
  shape: {
576
532
  shape$: symbol;