@goast/typescript 0.0.5 → 0.2.1

package/assets/{service → client}/angular/request-builder.ts

@@ -40,7 +40,7 @@ abstract class Parameter {
     public value: any,
     public options: ParameterOptions,
     defaultStyle: string,
-    defaultExplode: boolean
+    defaultExplode: boolean,
   ) {
     this.options = options || {};
     if (this.options.style === null || this.options.style === undefined) {
@@ -220,7 +220,11 @@ export class RequestBuilder {
   _bodyContent: any | null;
   _bodyContentType?: string;
 
-  constructor(public rootUrl: string, public operationPath: string, public method: string) {}
+  constructor(
+    public rootUrl: string,
+    public operationPath: string,
+    public method: string,
+  ) {}
 
   /**
    * Sets a path parameter

package/assets/client/fetch/{url-builder.ts → fetch-client.utils.ts}

@@ -1,3 +1,18 @@
+type _VoidResponse = Omit<Response, 'json'> & {
+  isVoidResponse: true;
+};
+type _TypedResponse<T> = Response & {
+  json(): Promise<T>;
+  isVoidResponse: false;
+};
+export type TypedResponse<T> = void extends T ? _VoidResponse : _TypedResponse<T>;
+
+export type FetchClientOptions = {
+  baseUrl?: string;
+  fetch?: typeof fetch;
+  headers?: Record<string, string>;
+};
+
 export class UrlBuilder {
   private path: string = '';
   private pathParams: Record<string, string> = {};

package/assets/stubs/easy-network-stub/easy-network-stub.utils.ts

@@ -0,0 +1,258 @@
+import { EasyNetworkStub, ErrorResponse, HttpMethod, RouteResponseCallback } from 'easy-network-stub';
+
+/**
+ * Options for the `EasyNetworkStubWrapper`.
+ */
+export type EasyNetworkStubWrapperOptions = {
+  /**
+   * Delay in milliseconds before responding.
+   * @default 0
+   */
+  delay: number;
+  /**
+   * Whether to log requests to the console.
+   * @default false
+   */
+  logRequests: boolean;
+  /**
+   * Whether to log responses to the console.
+   * @default false
+   */
+  logResponses: boolean;
+  /**
+   * Whether to remember requests. Remebered requests can be accessed via the `requests` property.
+   * @default false
+   */
+  rememberRequests: boolean;
+  /**
+   * Function to call when a response is sent.
+   * @param response The response that was sent.
+   * @default undefined
+   */
+  responseCallback?: (response: unknown) => void;
+  /**
+   * A prefix to add to the URL in log messages.
+   * @default /api/
+   */
+  logUrlPrefix: string;
+};
+
+/**
+ * Represents a request intercepted by the `EasyNetworkStubWrapper`.
+ */
+export type StubRequestItem = {
+  /**
+   * The HTTP method of the request.
+   */
+  method: HttpMethod;
+  /**
+   * The route of the request.
+   */
+  route: string;
+  /**
+   * The request information provided by `easy-network-stub`.
+   */
+  request: StubRequestInfo;
+};
+
+/**
+ * Represents the request information provided by `easy-network-stub`.
+ */
+export type StubRequestInfo<TRoute extends string = string, TBody = unknown> = Parameters<
+  RouteResponseCallback<TRoute, TBody>
+>[0];
+
+/**
+ * A strict version of `RouteResponseCallback` that allows for a responder to be passed as the first argument.
+ */
+export type StrictRouteResponseCallback<T, P extends string, R> = (
+  respondWith: R,
+  ...args: Parameters<RouteResponseCallback<P, T>>
+) => ErrorResponse<any> | Promise<ErrorResponse<any>>;
+
+type _UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+type __StubResponder<T extends Record<number, unknown>, S> = S extends number
+  ? [T[S]] extends [never]
+    ? (statusCode: S) => ErrorResponse<T[S]>
+    : (statusCode: S, content: T[S]) => ErrorResponse<T[S]>
+  : never;
+type _StubResponder<T extends Record<number, unknown>> = _UnionToIntersection<__StubResponder<T, keyof T>>;
+const untypedResponder = (statusCode: number, content?: unknown) => ({ statusCode, content });
+
+/**
+ * Gets the responder function typed to a specific set of status codes.
+ * @returns The responder function.
+ */
+export function getStubResponder<T extends Record<number, unknown>>(): _StubResponder<T> {
+  return untypedResponder as _StubResponder<T>;
+}
+
+/**
+ * Wrapper for `EasyNetworkStub` that adds additional functionality.
+ */
+export class EasyNetworkStubWrapper {
+  private _requests: StubRequestItem[] = [];
+
+  /**
+   * The options for the wrapper.
+   */
+  public readonly options: Readonly<EasyNetworkStubWrapperOptions>;
+
+  /**
+   * The requests that have been intercepted by the wrapper.
+   */
+  public get requests(): ReadonlyArray<StubRequestItem> {
+    return this._requests;
+  }
+
+  constructor(
+    public readonly wrappedStub: EasyNetworkStub,
+    options?: Partial<EasyNetworkStubWrapperOptions>,
+  ) {
+    this.options = {
+      delay: options?.delay ?? 0,
+      logRequests: options?.logRequests ?? false,
+      logResponses: options?.logResponses ?? false,
+      rememberRequests: options?.rememberRequests ?? false,
+      responseCallback: options?.responseCallback,
+      logUrlPrefix: options?.logUrlPrefix ?? '/api/',
+    };
+  }
+
+  /**
+   * Add a single api stub to your intercepted routes.
+   * @param method The http method that should be stubbed
+   * @param route The route that should be stubbed. Supports parameters in the form of {name:type}.
+   * @param response The callback in which you can process the request and reply with the stub. When a Promise is returned, the stub response will be delayed until it is resolved.
+   */
+  public stub<Route extends string>(
+    method: HttpMethod,
+    route: Route,
+    response: RouteResponseCallback<Route, unknown>,
+  ): void {
+    this.wrappedStub.stub<Route>(method, route, async (request) => {
+      if (this.options.delay > 0) await sleep(this.options.delay);
+      return await this.runRequest(method, route, response, request);
+    });
+  }
+
+  /**
+   * The stub2 method provides a way to set the type of the body that is sent.
+   * Due to restrictions in TypeScript (https://github.com/microsoft/TypeScript/issues/10571, https://github.com/Microsoft/TypeScript/pull/26349),
+   * We have to hacke a bit here. Calling stub2<T>() will return the stub method with a body of type T.
+   *
+   * Usage:
+   * ```
+   * .stub2<MyRequest>()('GET', '/api/test', ({ body }) => {
+   *   // body is of type MyRequest
+   * });
+   * ```
+   * @returns The stub method with a body of type T.
+   */
+  public stub2<T>(): <Route extends string>(
+    method: HttpMethod,
+    route: Route,
+    response: RouteResponseCallback<Route, T>,
+  ) => void {
+    return <Route extends string>(method: HttpMethod, route: Route, response: RouteResponseCallback<Route, T>) => {
+      this.wrappedStub.stub2<T>()<Route>(method, route, async (request) => {
+        if (this.options.delay > 0) await sleep(this.options.delay);
+        return await this.runRequest(method, route, response, request);
+      });
+    };
+  }
+
+  /**
+   * Reset the stubs and requests.
+   */
+  public reset(): void {
+    this._requests = [];
+    this.wrappedStub['_config'].stubs = [];
+  }
+
+  private async runRequest<Route extends string, T>(
+    method: HttpMethod,
+    route: Route,
+    response: RouteResponseCallback<Route, T>,
+    request: StubRequestInfo<Route, T>,
+  ): Promise<unknown> {
+    if (this.options.rememberRequests) {
+      this._requests.push({ method, route, request });
+    }
+    this.log('request', method, route, request, '#7FFFFF');
+    try {
+      const r = await response(request);
+      this.options.responseCallback?.(r);
+      this.log('response', method, route, r, '#7FFF8E');
+      return r;
+    } catch (error: unknown) {
+      this.options.responseCallback?.(error);
+      if (isHttpResponse(error) && error.statusCode >= 200 && error.statusCode < 300) {
+        this.log('response', method, route, error.content, '#7FFF8E');
+        throw error;
+      } else {
+        const isError = isHttpResponse(error) && error.statusCode >= 400 && error.statusCode < 600;
+        this.log('response', method, route, error, isError ? '#FF7F7F' : '7F7F7F');
+        throw error;
+      }
+    }
+  }
+
+  private log(type: 'request' | 'response', method: HttpMethod, route: string, data: unknown, color: string) {
+    if (type === 'request' && !this.options.logRequests) return;
+    if (type === 'response' && !this.options.logResponses) return;
+    const typeDisplay = type === 'request' ? ' [req]' : '[resp]';
+    const strippedRoute = route.match(/[^?]*(?=\?)?/)?.[0];
+    console.log(`%c${typeDisplay} ${method}: ${this.options.logUrlPrefix}${strippedRoute}`, `color:${color};`, data);
+  }
+}
+
+/**
+ * Base class for generated easy network stubs.
+ */
+export class EasyNetworkStubBase {
+  protected readonly stubWrapper: EasyNetworkStubWrapper;
+  protected readonly ownsStubWrapper: boolean;
+
+  constructor(stub: EasyNetworkStub | EasyNetworkStubWrapper, options?: EasyNetworkStubWrapperOptions) {
+    this.stubWrapper = stub instanceof EasyNetworkStubWrapper ? stub : new EasyNetworkStubWrapper(stub, options);
+    this.ownsStubWrapper = !(stub instanceof EasyNetworkStubWrapper);
+  }
+
+  public reset() {
+    if (this.ownsStubWrapper) {
+      this.stubWrapper.reset();
+    }
+  }
+}
+
+export type EasyNetworkStubGroup<Group, GroupContainer> = Group & {
+  (stubActions: (stubs: Group) => void): GroupContainer;
+};
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+declare interface GroupType<T> extends Function {
+  new (stubWrapper: EasyNetworkStubWrapper): T;
+}
+
+export function createEasyNetworkStubGroup<GroupContainer, Group>(
+  container: GroupContainer,
+  stubWrapper: EasyNetworkStubWrapper,
+  groupType: GroupType<Group>,
+): EasyNetworkStubGroup<Group, GroupContainer> {
+  const group = new groupType(stubWrapper);
+  const groupFn = (stubActions: (stubs: Group) => void) => {
+    stubActions(group);
+    return container;
+  };
+  Object.setPrototypeOf(groupFn, groupType.prototype);
+  return Object.assign(groupFn, group);
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isHttpResponse(value: unknown): value is ErrorResponse<unknown> {
+  return typeof value === 'object' && value !== null && 'statusCode' in value;
+}

package/cjs/lib/ast/_index.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Property = exports.parameter = exports.Parameter = exports.objectType = exports.ObjectType = exports.object = exports.Object = exports.method = exports.Method = exports.lookupType = exports.LookupType = exports.intersectionType = exports.IntersectionType = exports.interface = exports.Interface = exports.indexer = exports.Indexer = exports.genericParameter = exports.GenericParameter = exports.functionType = exports.FunctionType = exports.function = exports.Function = exports.export = exports.Export = exports.enumValue = exports.EnumValue = exports.enum = exports.Enum = exports.docTag = exports.DocTag = exports.doc = exports.Doc = exports.decorator = exports.Decorator = exports.constructorParameter = exports.ConstructorParameter = exports.constructor = exports.Constructor = exports.class = exports.Class = exports.call = exports.Call = exports.arrowFunction = exports.ArrowFunction = exports.arrayType = exports.ArrayType = exports.argument = exports.Argument = exports.Node = void 0;
+exports.toNode = exports.getBuilderOptions = exports.refs = exports.typeof = exports.Typeof = exports.variable = exports.Variable = exports.unionType = exports.UnionType = exports.typeAlias = exports.TypeAlias = exports.tuple = exports.Tuple = exports.string = exports.String = exports.reference = exports.Reference = exports.property = void 0;
+const tslib_1 = require("tslib");
+var node_1 = require("./node");
+Object.defineProperty(exports, "Node", { enumerable: true, get: function () { return node_1.TsNode; } });
+var argument_1 = require("./nodes/argument");
+Object.defineProperty(exports, "Argument", { enumerable: true, get: function () { return argument_1.TsArgument; } });
+Object.defineProperty(exports, "argument", { enumerable: true, get: function () { return argument_1.tsArgument; } });
+var array_type_1 = require("./nodes/array-type");
+Object.defineProperty(exports, "ArrayType", { enumerable: true, get: function () { return array_type_1.TsArrayType; } });
+Object.defineProperty(exports, "arrayType", { enumerable: true, get: function () { return array_type_1.tsArrayType; } });
+var arrow_function_1 = require("./nodes/arrow-function");
+Object.defineProperty(exports, "ArrowFunction", { enumerable: true, get: function () { return arrow_function_1.TsArrowFunction; } });
+Object.defineProperty(exports, "arrowFunction", { enumerable: true, get: function () { return arrow_function_1.tsArrowFunction; } });
+var call_1 = require("./nodes/call");
+Object.defineProperty(exports, "Call", { enumerable: true, get: function () { return call_1.TsCall; } });
+Object.defineProperty(exports, "call", { enumerable: true, get: function () { return call_1.tsCall; } });
+var class_1 = require("./nodes/class");
+Object.defineProperty(exports, "Class", { enumerable: true, get: function () { return class_1.TsClass; } });
+Object.defineProperty(exports, "class", { enumerable: true, get: function () { return class_1.tsClass; } });
+var constructor_1 = require("./nodes/constructor");
+Object.defineProperty(exports, "Constructor", { enumerable: true, get: function () { return constructor_1.TsConstructor; } });
+Object.defineProperty(exports, "constructor", { enumerable: true, get: function () { return constructor_1.tsConstructor; } });
+var constructor_parameter_1 = require("./nodes/constructor-parameter");
+Object.defineProperty(exports, "ConstructorParameter", { enumerable: true, get: function () { return constructor_parameter_1.TsConstructorParameter; } });
+Object.defineProperty(exports, "constructorParameter", { enumerable: true, get: function () { return constructor_parameter_1.tsConstructorParameter; } });
+var decorator_1 = require("./nodes/decorator");
+Object.defineProperty(exports, "Decorator", { enumerable: true, get: function () { return decorator_1.TsDecorator; } });
+Object.defineProperty(exports, "decorator", { enumerable: true, get: function () { return decorator_1.tsDecorator; } });
+var doc_1 = require("./nodes/doc");
+Object.defineProperty(exports, "Doc", { enumerable: true, get: function () { return doc_1.TsDoc; } });
+Object.defineProperty(exports, "doc", { enumerable: true, get: function () { return doc_1.tsDoc; } });
+var doc_tag_1 = require("./nodes/doc-tag");
+Object.defineProperty(exports, "DocTag", { enumerable: true, get: function () { return doc_tag_1.TsDocTag; } });
+Object.defineProperty(exports, "docTag", { enumerable: true, get: function () { return doc_tag_1.tsDocTag; } });
+var enum_1 = require("./nodes/enum");
+Object.defineProperty(exports, "Enum", { enumerable: true, get: function () { return enum_1.TsEnum; } });
+Object.defineProperty(exports, "enum", { enumerable: true, get: function () { return enum_1.tsEnum; } });
+var enum_value_1 = require("./nodes/enum-value");
+Object.defineProperty(exports, "EnumValue", { enumerable: true, get: function () { return enum_value_1.TsEnumValue; } });
+Object.defineProperty(exports, "enumValue", { enumerable: true, get: function () { return enum_value_1.tsEnumValue; } });
+var export_1 = require("./nodes/export");
+Object.defineProperty(exports, "Export", { enumerable: true, get: function () { return export_1.TsExport; } });
+Object.defineProperty(exports, "export", { enumerable: true, get: function () { return export_1.tsExport; } });
+var function_1 = require("./nodes/function");
+Object.defineProperty(exports, "Function", { enumerable: true, get: function () { return function_1.TsFunction; } });
+Object.defineProperty(exports, "function", { enumerable: true, get: function () { return function_1.tsFunction; } });
+var function_type_1 = require("./nodes/function-type");
+Object.defineProperty(exports, "FunctionType", { enumerable: true, get: function () { return function_type_1.TsFunctionType; } });
+Object.defineProperty(exports, "functionType", { enumerable: true, get: function () { return function_type_1.tsFunctionType; } });
+var generic_parameter_1 = require("./nodes/generic-parameter");
+Object.defineProperty(exports, "GenericParameter", { enumerable: true, get: function () { return generic_parameter_1.TsGenericParameter; } });
+Object.defineProperty(exports, "genericParameter", { enumerable: true, get: function () { return generic_parameter_1.tsGenericParameter; } });
+var indexer_1 = require("./nodes/indexer");
+Object.defineProperty(exports, "Indexer", { enumerable: true, get: function () { return indexer_1.TsIndexer; } });
+Object.defineProperty(exports, "indexer", { enumerable: true, get: function () { return indexer_1.tsIndexer; } });
+var interface_1 = require("./nodes/interface");
+Object.defineProperty(exports, "Interface", { enumerable: true, get: function () { return interface_1.TsInterface; } });
+Object.defineProperty(exports, "interface", { enumerable: true, get: function () { return interface_1.tsInterface; } });
+var intersection_type_1 = require("./nodes/intersection-type");
+Object.defineProperty(exports, "IntersectionType", { enumerable: true, get: function () { return intersection_type_1.TsIntersectionType; } });
+Object.defineProperty(exports, "intersectionType", { enumerable: true, get: function () { return intersection_type_1.tsIntersectionType; } });
+var lookup_type_1 = require("./nodes/lookup-type");
+Object.defineProperty(exports, "LookupType", { enumerable: true, get: function () { return lookup_type_1.TsLookupType; } });
+Object.defineProperty(exports, "lookupType", { enumerable: true, get: function () { return lookup_type_1.tsLookupType; } });
+var method_1 = require("./nodes/method");
+Object.defineProperty(exports, "Method", { enumerable: true, get: function () { return method_1.TsMethod; } });
+Object.defineProperty(exports, "method", { enumerable: true, get: function () { return method_1.tsMethod; } });
+var object_1 = require("./nodes/object");
+Object.defineProperty(exports, "Object", { enumerable: true, get: function () { return object_1.TsObject; } });
+Object.defineProperty(exports, "object", { enumerable: true, get: function () { return object_1.tsObject; } });
+var object_type_1 = require("./nodes/object-type");
+Object.defineProperty(exports, "ObjectType", { enumerable: true, get: function () { return object_type_1.TsObjectType; } });
+Object.defineProperty(exports, "objectType", { enumerable: true, get: function () { return object_type_1.tsObjectType; } });
+var parameter_1 = require("./nodes/parameter");
+Object.defineProperty(exports, "Parameter", { enumerable: true, get: function () { return parameter_1.TsParameter; } });
+Object.defineProperty(exports, "parameter", { enumerable: true, get: function () { return parameter_1.tsParameter; } });
+var property_1 = require("./nodes/property");
+Object.defineProperty(exports, "Property", { enumerable: true, get: function () { return property_1.TsProperty; } });
+Object.defineProperty(exports, "property", { enumerable: true, get: function () { return property_1.tsProperty; } });
+var reference_1 = require("./nodes/reference");
+Object.defineProperty(exports, "Reference", { enumerable: true, get: function () { return reference_1.TsReference; } });
+Object.defineProperty(exports, "reference", { enumerable: true, get: function () { return reference_1.tsReference; } });
+var string_1 = require("./nodes/string");
+Object.defineProperty(exports, "String", { enumerable: true, get: function () { return string_1.TsString; } });
+Object.defineProperty(exports, "string", { enumerable: true, get: function () { return string_1.tsString; } });
+var tuple_1 = require("./nodes/tuple");
+Object.defineProperty(exports, "Tuple", { enumerable: true, get: function () { return tuple_1.TsTuple; } });
+Object.defineProperty(exports, "tuple", { enumerable: true, get: function () { return tuple_1.tsTuple; } });
+var type_alias_1 = require("./nodes/type-alias");
+Object.defineProperty(exports, "TypeAlias", { enumerable: true, get: function () { return type_alias_1.TsTypeAlias; } });
+Object.defineProperty(exports, "typeAlias", { enumerable: true, get: function () { return type_alias_1.tsTypeAlias; } });
+var union_type_1 = require("./nodes/union-type");
+Object.defineProperty(exports, "UnionType", { enumerable: true, get: function () { return union_type_1.TsUnionType; } });
+Object.defineProperty(exports, "unionType", { enumerable: true, get: function () { return union_type_1.tsUnionType; } });
+var variable_1 = require("./nodes/variable");
+Object.defineProperty(exports, "Variable", { enumerable: true, get: function () { return variable_1.TsVariable; } });
+Object.defineProperty(exports, "variable", { enumerable: true, get: function () { return variable_1.tsVariable; } });
+var typeof_1 = require("./nodes/typeof");
+Object.defineProperty(exports, "Typeof", { enumerable: true, get: function () { return typeof_1.TsTypeof; } });
+Object.defineProperty(exports, "typeof", { enumerable: true, get: function () { return typeof_1.tsTypeof; } });
+exports.refs = tslib_1.__importStar(require("./references"));
+var get_type_script_builder_options_1 = require("./utils/get-type-script-builder-options");
+Object.defineProperty(exports, "getBuilderOptions", { enumerable: true, get: function () { return get_type_script_builder_options_1.getTypeScriptBuilderOptions; } });
+var to_ts_node_1 = require("./utils/to-ts-node");
+Object.defineProperty(exports, "toNode", { enumerable: true, get: function () { return to_ts_node_1.toTsNode; } });

package/cjs/lib/ast/common.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/lib/ast/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ts = void 0;
+const tslib_1 = require("tslib");
+exports.ts = tslib_1.__importStar(require("./_index"));

package/cjs/lib/ast/node.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TsNode = void 0;
+const core_1 = require("@goast/core");
+class TsNode extends core_1.AstNode {
+    constructor(options) {
+        super(options);
+    }
+}
+exports.TsNode = TsNode;

package/cjs/lib/ast/nodes/argument.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsArgument = exports.TsArgument = void 0;
+const node_1 = require("../node");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+const write_ts_parameters_1 = require("../utils/write-ts-parameters");
+class TsArgument extends node_1.TsNode {
+    constructor(options) {
+        super(options);
+        this.value = options.value;
+    }
+    onWrite(builder) {
+        (0, write_ts_nodes_1.writeTsNode)(builder, this.value);
+    }
+}
+exports.TsArgument = TsArgument;
+const createArgument = (value, options) => new TsArgument(Object.assign(Object.assign({}, options), { value }));
+exports.tsArgument = Object.assign(createArgument, {
+    write: write_ts_parameters_1.writeTsParameters,
+});

package/cjs/lib/ast/nodes/array-type.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsArrayType = exports.TsArrayType = void 0;
+const node_1 = require("../node");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsArrayType extends node_1.TsNode {
+    constructor(options) {
+        var _a;
+        super(options);
+        this.readonly = (_a = options.readonly) !== null && _a !== void 0 ? _a : false;
+        this.type = options.type;
+    }
+    onWrite(builder) {
+        if (this.readonly)
+            builder.append('readonly ');
+        builder
+            .append(this.inject.beforeType)
+            .parenthesize('()', (b) => (0, write_ts_nodes_1.writeTsNode)(b, this.type))
+            .append(this.inject.afterType);
+        builder.append('[]');
+    }
+}
+exports.TsArrayType = TsArrayType;
+const createArrayType = (type, options) => new TsArrayType(Object.assign(Object.assign({}, options), { type }));
+exports.tsArrayType = Object.assign(createArrayType, {
+    write: write_ts_nodes_1.writeTsNodes,
+});

package/cjs/lib/ast/nodes/arrow-function.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsArrowFunction = exports.TsArrowFunction = void 0;
+const core_1 = require("@goast/core");
+const generic_parameter_1 = require("./generic-parameter");
+const parameter_1 = require("./parameter");
+const node_1 = require("../node");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsArrowFunction extends node_1.TsNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        super(options);
+        this.async = (_a = options.async) !== null && _a !== void 0 ? _a : false;
+        this.generics = (_c = (_b = options.generics) === null || _b === void 0 ? void 0 : _b.filter(core_1.notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.parameters = (_e = (_d = options.parameters) === null || _d === void 0 ? void 0 : _d.filter(core_1.notNullish)) !== null && _e !== void 0 ? _e : [];
+        this.returnType = (_f = options.returnType) !== null && _f !== void 0 ? _f : null;
+        this.singleExpression = (_g = options.singleExpression) !== null && _g !== void 0 ? _g : false;
+        this.body = (_h = options.body) !== null && _h !== void 0 ? _h : null;
+    }
+    onWrite(builder) {
+        if (this.async) {
+            builder.append('async ');
+        }
+        builder.append(this.inject.beforeGenerics);
+        generic_parameter_1.tsGenericParameter.write(builder, this.generics);
+        builder.append(this.inject.afterGenerics);
+        builder.append(this.inject.beforeParams);
+        parameter_1.tsParameter.write(builder, this.parameters);
+        builder.append(this.inject.afterParams);
+        if (this.returnType) {
+            builder.append(': ');
+            builder.append(this.inject.beforeReturnType);
+            (0, write_ts_nodes_1.writeTsNode)(builder, this.returnType);
+            builder.append(this.inject.afterReturnType);
+        }
+        builder.append(' => ');
+        builder.append(this.inject.beforeBody);
+        if (this.singleExpression && this.body) {
+            builder.append(this.body);
+        }
+        else {
+            builder.parenthesize('{}', this.body, { multiline: !!this.body });
+        }
+        builder.append(this.inject.afterBody);
+    }
+}
+exports.TsArrowFunction = TsArrowFunction;
+const createArrowFunction = (options) => new TsArrowFunction(options !== null && options !== void 0 ? options : {});
+exports.tsArrowFunction = Object.assign(createArrowFunction, {
+    write: write_ts_nodes_1.writeTsNodes,
+});

package/cjs/lib/ast/nodes/call.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsCall = exports.TsCall = void 0;
+const core_1 = require("@goast/core");
+const argument_1 = require("./argument");
+const node_1 = require("../node");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsCall extends node_1.TsNode {
+    constructor(options) {
+        var _a, _b;
+        super(options);
+        this.path = options.path.filter(core_1.notNullish);
+        this.arguments = (_b = (_a = options.arguments) === null || _a === void 0 ? void 0 : _a.filter(core_1.notNullish)) !== null && _b !== void 0 ? _b : null;
+    }
+    onWrite(builder) {
+        (0, write_ts_nodes_1.writeTsNodes)(builder, this.path, { separator: '.' });
+        if (this.arguments) {
+            argument_1.tsArgument.write(builder, this.arguments);
+        }
+    }
+}
+exports.TsCall = TsCall;
+const createCall = (path, args, options) => new TsCall(Object.assign(Object.assign({}, options), { path: Array.isArray(path) ? path : [path], arguments: args }));
+exports.tsCall = Object.assign(createCall, {
+    write: write_ts_nodes_1.writeTsNodes,
+});

package/cjs/lib/ast/nodes/class.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsClass = exports.TsClass = void 0;
+const core_1 = require("@goast/core");
+const decorator_1 = require("./decorator");
+const doc_1 = require("./doc");
+const generic_parameter_1 = require("./generic-parameter");
+const node_1 = require("../node");
+const write_ts_members_1 = require("../utils/write-ts-members");
+const write_ts_nodes_1 = require("../utils/write-ts-nodes");
+class TsClass extends node_1.TsNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        super(options);
+        this.doc = (_a = options.doc) !== null && _a !== void 0 ? _a : null;
+        this.decorators = (_c = (_b = options.decorators) === null || _b === void 0 ? void 0 : _b.filter(core_1.notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.export = (_d = options.export) !== null && _d !== void 0 ? _d : false;
+        this.abstract = (_e = options.abstract) !== null && _e !== void 0 ? _e : false;
+        this.name = options.name;
+        this.generics = (_g = (_f = options.generics) === null || _f === void 0 ? void 0 : _f.filter(core_1.notNullish)) !== null && _g !== void 0 ? _g : [];
+        this.extends = (_h = options.extends) !== null && _h !== void 0 ? _h : null;
+        this.implements = (_k = (_j = options.implements) === null || _j === void 0 ? void 0 : _j.filter(core_1.notNullish)) !== null && _k !== void 0 ? _k : [];
+        this.members = (_m = (_l = options.members) === null || _l === void 0 ? void 0 : _l.filter(core_1.notNullish)) !== null && _m !== void 0 ? _m : [];
+    }
+    onWrite(builder) {
+        builder.append(this.inject.beforeDoc);
+        doc_1.tsDoc.write(builder, doc_1.tsDoc.get(this.doc, { generics: this.generics }));
+        builder.append(this.inject.afterDoc);
+        builder.append(this.inject.beforeDecorators);
+        decorator_1.tsDecorator.write(builder, this.decorators, { multiline: true });
+        builder.append(this.inject.afterDecorators);
+        builder.append(this.inject.beforeModifiers);
+        if (this.export)
+            builder.append('export ');
+        if (this.abstract)
+            builder.append('abstract ');
+        builder.append(this.inject.afterModifiers);
+        builder.append('class ');
+        builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+        builder.append(this.inject.beforeGenerics);
+        generic_parameter_1.tsGenericParameter.write(builder, this.generics);
+        builder.append(this.inject.afterGenerics);
+        if (this.extends) {
+            builder.append(' extends ');
+            builder.append(this.inject.beforeExtends);
+            (0, write_ts_nodes_1.writeTsNode)(builder, this.extends);
+            builder.append(this.inject.afterExtends);
+        }
+        if (this.implements.length > 0) {
+            builder.append(' implements ');
+            builder.append(this.inject.beforeImplements);
+            (0, write_ts_nodes_1.writeTsNodes)(builder, this.implements, { separator: ', ' });
+            builder.append(this.inject.afterImplements);
+        }
+        builder.append(' ');
+        builder.append(this.inject.beforeBody);
+        builder.parenthesize('{}', (b) => {
+            b.append(this.inject.beforeMembers);
+            (0, write_ts_members_1.writeTsMembers)(b, this.members);
+            b.append(this.inject.afterMembers);
+        }, { multiline: this.members.length > 0 });
+        builder.append(this.inject.afterBody);
+        builder.appendLine();
+    }
+}
+exports.TsClass = TsClass;
+const createClass = (name, options) => new TsClass(Object.assign(Object.assign({}, options), { name }));
+exports.tsClass = Object.assign(createClass, {
+    write: write_ts_nodes_1.writeTsNodes,
+});