Merge pull request #3666 from hey-api/chore/ts-dsl-bump

chore: update ts-dsl

Author: mrlubos

packages/openapi-ts/src/ts-dsl/decl/func.ts

@@ -10,6 +10,7 @@ import { DocMixin } from '../mixins/doc';
 import {
   AbstractMixin,
   AsyncMixin,
+  ExportMixin,
   PrivateMixin,
   ProtectedMixin,
   PublicMixin,
@@ -29,11 +30,13 @@ const Mixed = AbstractMixin(
       DecoratorMixin(
         DoMixin(
           DocMixin(
-            ParamMixin(
-              PrivateMixin(
-                ProtectedMixin(
-                  PublicMixin(
-                    StaticMixin(TypeParamsMixin(TypeReturnsMixin(TsDsl<ts.ArrowFunction>))),
+            ExportMixin(
+              ParamMixin(
+                PrivateMixin(
+                  ProtectedMixin(
+                    PublicMixin(
+                      StaticMixin(TypeParamsMixin(TypeReturnsMixin(TsDsl<ts.ArrowFunction>))),
+                    ),
                   ),
                 ),
               ),

packages/openapi-ts/src/ts-dsl/decl/method.ts

@@ -19,8 +19,11 @@ import { TypeParamsMixin } from '../mixins/type-params';
 import { TypeReturnsMixin } from '../mixins/type-returns';
 import { BlockTsDsl } from '../stmt/block';
 import { TokenTsDsl } from '../token';
+import { f } from '../utils/factories';
 import { safeAccessorName } from '../utils/name';
 
+export type MethodCtor = (name: NodeName, fn?: (m: MethodTsDsl) => void) => MethodTsDsl;
+
 const Mixed = AbstractMixin(
   AsyncMixin(
     DecoratorMixin(
@@ -78,3 +81,5 @@ export class MethodTsDsl extends Mixed {
     return this.$docs(node);
   }
 }
+
+f.method.set((...args) => new MethodTsDsl(...args));

packages/openapi-ts/src/ts-dsl/decl/param.ts

@@ -45,8 +45,8 @@ export class ParamTsDsl extends Mixed {
   }
 
   /** Sets the parameter type. */
-  type(type: string | TypeTsDsl): this {
-    this._type = type instanceof TypeTsDsl ? type : new TypeExprTsDsl(type);
+  type(node: NodeName | TypeTsDsl): this {
+    this._type = node instanceof TypeTsDsl ? node : new TypeExprTsDsl(node);
     return this;
   }
 

packages/openapi-ts/src/ts-dsl/expr/array.ts

@@ -6,60 +6,49 @@ import { TsDsl } from '../base';
 import { AsMixin } from '../mixins/as';
 import { ExprMixin } from '../mixins/expr';
 import { LayoutMixin } from '../mixins/layout';
+import { SpreadMixin } from '../mixins/spread';
 import { LiteralTsDsl } from './literal';
 
-const Mixed = AsMixin(ExprMixin(LayoutMixin(TsDsl<ts.ArrayLiteralExpression>)));
+export type ArrayExpr = string | number | boolean | MaybeTsDsl<ts.Expression>;
+
+const Mixed = AsMixin(ExprMixin(LayoutMixin(SpreadMixin(TsDsl<ts.ArrayLiteralExpression>))));
 
 export class ArrayTsDsl extends Mixed {
   readonly '~dsl' = 'ArrayTsDsl';
 
-  protected _elements: Array<
-    | { expr: MaybeTsDsl<ts.Expression>; kind: 'element' }
-    | { expr: MaybeTsDsl<ts.Expression>; kind: 'spread' }
-  > = [];
+  protected _elements: Array<MaybeTsDsl<ts.Expression>> = [];
 
-  constructor(...exprs: Array<string | number | boolean | MaybeTsDsl<ts.Expression>>) {
+  constructor(...exprs: Array<ArrayExpr>) {
     super();
     this.elements(...exprs);
   }
 
   override analyze(ctx: AnalysisContext): void {
     super.analyze(ctx);
     for (const item of this._elements) {
-      ctx.analyze(item.expr);
+      ctx.analyze(item);
     }
   }
 
   /** Adds a single array element. */
-  element(expr: string | number | boolean | MaybeTsDsl<ts.Expression>): this {
+  element(expr: ArrayExpr): this {
     const node =
       typeof expr === 'string' || typeof expr === 'number' || typeof expr === 'boolean'
         ? new LiteralTsDsl(expr)
         : expr;
-    this._elements.push({ expr: node, kind: 'element' });
+    this._elements.push(node);
     return this;
   }
 
   /** Adds multiple array elements. */
-  elements(...exprs: ReadonlyArray<string | number | boolean | MaybeTsDsl<ts.Expression>>): this {
+  elements(...exprs: ReadonlyArray<ArrayExpr>): this {
     for (const expr of exprs) this.element(expr);
     return this;
   }
 
-  /** Adds a spread element (`...expr`). */
-  spread(expr: MaybeTsDsl<ts.Expression>): this {
-    this._elements.push({ expr, kind: 'spread' });
-    return this;
-  }
-
   override toAst() {
-    const elements = this._elements.map((item) => {
-      const node = this.$node(item.expr);
-      return item.kind === 'spread' ? ts.factory.createSpreadElement(node) : node;
-    });
-
     return ts.factory.createArrayLiteralExpression(
-      elements,
+      this._elements.map((item) => this.$node(item)),
       this.$multiline(this._elements.length),
     );
   }

packages/openapi-ts/src/ts-dsl/expr/attr.ts

@@ -8,6 +8,7 @@ import { AsMixin } from '../mixins/as';
 import { ExprMixin } from '../mixins/expr';
 import { OperatorMixin } from '../mixins/operator';
 import { OptionalMixin } from '../mixins/optional';
+import { SpreadMixin } from '../mixins/spread';
 import { TokenTsDsl } from '../token';
 import { f } from '../utils/factories';
 import { regexp } from '../utils/regexp';
@@ -18,7 +19,9 @@ export type AttrCtor = (left: AttrLeft, right: NodeName) => AttrTsDsl;
 
 const Mixed = AsMixin(
   ExprMixin(
-    OperatorMixin(OptionalMixin(TsDsl<ts.PropertyAccessExpression | ts.ElementAccessExpression>)),
+    OperatorMixin(
+      OptionalMixin(SpreadMixin(TsDsl<ts.PropertyAccessExpression | ts.ElementAccessExpression>)),
+    ),
   ),
 );
 

packages/openapi-ts/src/ts-dsl/expr/call.ts

@@ -7,14 +7,15 @@ import { TsDsl } from '../base';
 import { ArgsMixin } from '../mixins/args';
 import { AsMixin } from '../mixins/as';
 import { ExprMixin } from '../mixins/expr';
+import { SpreadMixin } from '../mixins/spread';
 import { TypeArgsMixin } from '../mixins/type-args';
 import { f } from '../utils/factories';
 
 export type CallArgs = ReadonlyArray<CallCallee | undefined>;
 export type CallCallee = NodeName | MaybeTsDsl<ts.Expression>;
 export type CallCtor = (callee: CallCallee, ...args: CallArgs) => CallTsDsl;
 
-const Mixed = ArgsMixin(AsMixin(ExprMixin(TypeArgsMixin(TsDsl<ts.CallExpression>))));
+const Mixed = ArgsMixin(AsMixin(ExprMixin(SpreadMixin(TypeArgsMixin(TsDsl<ts.CallExpression>)))));
 
 export class CallTsDsl extends Mixed {
   readonly '~dsl' = 'CallTsDsl';

packages/openapi-ts/src/ts-dsl/expr/expr.ts

@@ -7,11 +7,12 @@ import { TsDsl } from '../base';
 import { AsMixin } from '../mixins/as';
 import { ExprMixin } from '../mixins/expr';
 import { OperatorMixin } from '../mixins/operator';
+import { SpreadMixin } from '../mixins/spread';
 import { TypeExprMixin } from '../mixins/type-expr';
 
 type Id = NodeName | MaybeTsDsl<ts.Expression>;
 
-const Mixed = AsMixin(ExprMixin(OperatorMixin(TypeExprMixin(TsDsl<ts.Expression>))));
+const Mixed = AsMixin(ExprMixin(OperatorMixin(SpreadMixin(TypeExprMixin(TsDsl<ts.Expression>)))));
 
 export class ExprTsDsl extends Mixed {
   readonly '~dsl' = 'ExprTsDsl';

packages/openapi-ts/src/ts-dsl/expr/new.ts

@@ -7,14 +7,15 @@ import { TsDsl } from '../base';
 import { ArgsMixin } from '../mixins/args';
 import { AsMixin } from '../mixins/as';
 import { ExprMixin } from '../mixins/expr';
+import { SpreadMixin } from '../mixins/spread';
 import { TypeArgsMixin } from '../mixins/type-args';
 import { f } from '../utils/factories';
 
 export type NewArgs = ReadonlyArray<NewExpr | undefined>;
 export type NewExpr = NodeName | MaybeTsDsl<ts.Expression>;
 export type NewCtor = (expr: NewExpr, ...args: NewArgs) => NewTsDsl;
 
-const Mixed = ArgsMixin(AsMixin(ExprMixin(TypeArgsMixin(TsDsl<ts.NewExpression>))));
+const Mixed = ArgsMixin(AsMixin(ExprMixin(SpreadMixin(TypeArgsMixin(TsDsl<ts.NewExpression>)))));
 
 export class NewTsDsl extends Mixed {
   readonly '~dsl' = 'NewTsDsl';

packages/openapi-ts/src/ts-dsl/expr/object.ts

@@ -3,16 +3,16 @@ import ts from 'typescript';
 
 import type { MaybeTsDsl } from '../base';
 import { TsDsl } from '../base';
+import type { MethodTsDsl } from '../decl/method';
 import { AsMixin } from '../mixins/as';
 import { ExprMixin } from '../mixins/expr';
 import { HintMixin } from '../mixins/hint';
 import { LayoutMixin } from '../mixins/layout';
+import { f } from '../utils/factories';
 import { ObjectPropTsDsl } from './prop';
 
 type Expr = NodeName | MaybeTsDsl<ts.Expression>;
 type Stmt = NodeName | MaybeTsDsl<ts.Statement>;
-type ExprFn = Expr | ((p: ObjectPropTsDsl) => void);
-type StmtFn = Stmt | ((p: ObjectPropTsDsl) => void);
 
 const Mixed = AsMixin(ExprMixin(HintMixin(LayoutMixin(TsDsl<ts.ObjectLiteralExpression>))));
 
@@ -22,9 +22,13 @@ export class ObjectTsDsl extends Mixed {
   protected _props = new Map<string, ObjectPropTsDsl>();
   protected _spreadCounter = 0;
 
-  constructor(...props: Array<ObjectPropTsDsl>) {
+  constructor(...props: Array<ObjectPropTsDsl> | [(o: ObjectTsDsl) => void]) {
     super();
-    this.props(...props);
+    if (props.length === 1 && typeof props[0] === 'function') {
+      props[0](this);
+    } else {
+      this.props(...(props as Array<ObjectPropTsDsl>));
+    }
   }
 
   override analyze(ctx: AnalysisContext): void {
@@ -43,7 +47,7 @@ export class ObjectTsDsl extends Mixed {
   }
 
   /** Adds a computed property (e.g., `{ [expr]: value }`), or removes if null. */
-  computed(name: string, expr: ExprFn | null): this {
+  computed(name: string, expr: Expr | null): this {
     if (expr === null) {
       this._props.delete(`computed:${name}`);
     } else {
@@ -56,7 +60,7 @@ export class ObjectTsDsl extends Mixed {
   }
 
   /** Adds a getter property (e.g., `{ get foo() { ... } }`), or removes if null. */
-  getter(name: string, stmt: StmtFn | null): this {
+  getter(name: string, stmt: Stmt | null): this {
     if (stmt === null) {
       this._props.delete(`getter:${name}`);
     } else {
@@ -75,8 +79,21 @@ export class ObjectTsDsl extends Mixed {
     return this._props.size === 0;
   }
 
+  /** Adds a method property (e.g., `{ foo() { ... } }`), or removes if null. */
+  method(name: string, fn: ((m: MethodTsDsl) => void) | null): this {
+    if (fn === null) {
+      this._props.delete(`method:${name}`);
+    } else {
+      this._props.set(
+        `method:${name}`,
+        new ObjectPropTsDsl({ kind: 'method', name }).value(f.method(name, fn)),
+      );
+    }
+    return this;
+  }
+
   /** Adds a property assignment, or removes if null. */
-  prop(name: string, expr: ExprFn | null): this {
+  prop(name: string, expr: Expr | null): this {
     if (expr === null) {
       this._props.delete(`prop:${name}`);
     } else {
@@ -94,7 +111,7 @@ export class ObjectTsDsl extends Mixed {
   }
 
   /** Adds a setter property (e.g., `{ set foo(v) { ... } }`), or removes if null. */
-  setter(name: string, stmt: StmtFn | null): this {
+  setter(name: string, stmt: Stmt | null): this {
     if (stmt === null) {
       this._props.delete(`setter:${name}`);
     } else {
@@ -104,7 +121,7 @@ export class ObjectTsDsl extends Mixed {
   }
 
   /** Adds a spread property (e.g., `{ ...options }`). */
-  spread(expr: ExprFn): this {
+  spread(expr: Expr): this {
     const key = `spread:${this._spreadCounter++}`;
     this._props.set(key, new ObjectPropTsDsl({ kind: 'spread' }).value(expr));
     return this;