@azure-tools/rlc-common 0.11.0

package/dist/metadata/buildTsConfig.js

@@ -0,0 +1,72 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTsConfig = void 0;
+const ts_morph_1 = require("ts-morph");
+const restLevelTsConfigInAzureSdkForJs = {
+    extends: "../../../tsconfig.package",
+    compilerOptions: {
+        outDir: "./dist-esm",
+        declarationDir: "./types"
+    },
+    include: ["src/**/*.ts"]
+};
+const restLevelTsConfigNotInAzureSdkForJs = {
+    compilerOptions: {
+        target: "ES2017",
+        module: "es6",
+        lib: [],
+        declaration: true,
+        declarationMap: true,
+        inlineSources: true,
+        sourceMap: true,
+        importHelpers: true,
+        strict: true,
+        alwaysStrict: true,
+        noUnusedLocals: true,
+        noUnusedParameters: true,
+        noImplicitReturns: true,
+        noFallthroughCasesInSwitch: true,
+        forceConsistentCasingInFileNames: true,
+        moduleResolution: "node",
+        allowSyntheticDefaultImports: true,
+        esModuleInterop: true,
+        outDir: "./dist-esm",
+        declarationDir: "./types"
+    },
+    include: ["./src/**/*.ts"]
+};
+function buildTsConfig(model, hasSamplesGenerated = false) {
+    var _a, _b;
+    const generateMetadata = Boolean((_a = model.options) === null || _a === void 0 ? void 0 : _a.generateMetadata);
+    if (!generateMetadata) {
+        return;
+    }
+    const { generateTest, packageDetails, generateSample, azureSdkForJs } = model.options || {};
+    const clientPackageName = (_b = packageDetails === null || packageDetails === void 0 ? void 0 : packageDetails.name) !== null && _b !== void 0 ? _b : "";
+    const project = new ts_morph_1.Project();
+    const restLevelTsConfig = azureSdkForJs
+        ? restLevelTsConfigInAzureSdkForJs
+        : restLevelTsConfigNotInAzureSdkForJs;
+    if (generateTest) {
+        restLevelTsConfig.include.push("./test/**/*.ts");
+    }
+    if (generateSample && hasSamplesGenerated) {
+        restLevelTsConfig.include.push("samples-dev/**/*.ts");
+        restLevelTsConfig.compilerOptions["paths"] = {};
+        restLevelTsConfig.compilerOptions["paths"][clientPackageName] = [
+            "./src/index"
+        ];
+    }
+    const filePath = "tsconfig.json";
+    const configFile = project.createSourceFile(filePath, JSON.stringify(restLevelTsConfig), {
+        overwrite: true
+    });
+    return {
+        path: filePath,
+        content: configFile.getFullText()
+    };
+}
+exports.buildTsConfig = buildTsConfig;
+//# sourceMappingURL=buildTsConfig.js.map

package/dist/metadata/buildTsConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildTsConfig.js","sourceRoot":"","sources":["../../src/metadata/buildTsConfig.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;;AAElC,uCAAmC;AAGnC,MAAM,gCAAgC,GAAwB;IAC5D,OAAO,EAAE,2BAA2B;IACpC,eAAe,EAAE;QACf,MAAM,EAAE,YAAY;QACpB,cAAc,EAAE,SAAS;KAC1B;IACD,OAAO,EAAE,CAAC,aAAa,CAAC;CACzB,CAAC;AAEF,MAAM,mCAAmC,GAAwB;IAC/D,eAAe,EAAE;QACf,MAAM,EAAE,QAAQ;QAChB,MAAM,EAAE,KAAK;QACb,GAAG,EAAE,EAAE;QACP,WAAW,EAAE,IAAI;QACjB,cAAc,EAAE,IAAI;QACpB,aAAa,EAAE,IAAI;QACnB,SAAS,EAAE,IAAI;QACf,aAAa,EAAE,IAAI;QACnB,MAAM,EAAE,IAAI;QACZ,YAAY,EAAE,IAAI;QAClB,cAAc,EAAE,IAAI;QACpB,kBAAkB,EAAE,IAAI;QACxB,iBAAiB,EAAE,IAAI;QACvB,0BAA0B,EAAE,IAAI;QAChC,gCAAgC,EAAE,IAAI;QACtC,gBAAgB,EAAE,MAAM;QACxB,4BAA4B,EAAE,IAAI;QAClC,eAAe,EAAE,IAAI;QACrB,MAAM,EAAE,YAAY;QACpB,cAAc,EAAE,SAAS;KAC1B;IACD,OAAO,EAAE,CAAC,eAAe,CAAC;CAC3B,CAAC;AAEF,SAAgB,aAAa,CAAC,KAAe,EAAE,mBAAmB,GAAG,KAAK;;IACxE,MAAM,gBAAgB,GAAG,OAAO,CAAC,MAAA,KAAK,CAAC,OAAO,0CAAE,gBAAgB,CAAC,CAAC;IAClE,IAAI,CAAC,gBAAgB,EAAE;QACrB,OAAO;KACR;IACD,MAAM,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,aAAa,EAAE,GACnE,KAAK,CAAC,OAAO,IAAI,EAAE,CAAC;IACtB,MAAM,iBAAiB,GAAG,MAAA,cAAc,aAAd,cAAc,uBAAd,cAAc,CAAE,IAAI,mCAAI,EAAE,CAAC;IACrD,MAAM,OAAO,GAAG,IAAI,kBAAO,EAAE,CAAC;IAE9B,MAAM,iBAAiB,GAAG,aAAa;QACrC,CAAC,CAAC,gCAAgC;QAClC,CAAC,CAAC,mCAAmC,CAAC;IAExC,IAAI,YAAY,EAAE;QAChB,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;KAClD;IACD,IAAI,cAAc,IAAI,mBAAmB,EAAE;QACzC,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;QACtD,iBAAiB,CAAC,eAAe,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC;QAChD,iBAAiB,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,iBAAiB,CAAC,GAAG;YAC9D,aAAa;SACd,CAAC;KACH;IAED,MAAM,QAAQ,GAAG,eAAe,CAAC;IACjC,MAAM,UAAU,GAAG,OAAO,CAAC,gBAAgB,CACzC,QAAQ,EACR,IAAI,CAAC,SAAS,CAAC,iBAAiB,CAAC,EACjC;QACE,SAAS,EAAE,IAAI;KAChB,CACF,CAAC;IACF,OAAO;QACL,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,UAAU,CAAC,WAAW,EAAE;KAClC,CAAC;AACJ,CAAC;AArCD,sCAqCC"}

package/dist/package.json

@@ -0,0 +1 @@
+{"name":"@azure-tools/rlc-common","version":"0.11.0","description":"","type":"commonjs","main":"dist/index.js","module":"dist-esm/index.js","exports":{".":{"types":"./types/index.d.ts","require":"./dist/index.js","import":"./dist-esm/index.js"}},"types":"./types/index.d.ts","scripts":{"lint":"eslint src --ext .ts --max-warnings=0","lint:fix":"eslint src --fix --ext .ts","format":"npm run -s prettier -- --write","check-format":"npm run prettier -- --check","prettier":"prettier --config ./.prettierrc src/**/*.ts","build":"rimraf dist/* dist-esm/* types/* && tsc -p tsconfig.json && tsc -p tsconfig-cjs.json && node publishPackage.js","build:cjs":"rimraf dist/* dist-esm/* types/* && tsc -p tsconfig-cjs.json && node publishPackage.js","build:esm":"rimraf dist/* dist-esm/* types/* && tsc -p tsconfig.json && node publishPackage.js","test":"echo \"Error: no test specified\" && exit 1"},"keywords":[],"author":"","license":"ISC","dependencies":{"ts-morph":"^15.1.0","lodash":"^4.17.21","handlebars":"^4.7.7"},"devDependencies":{"@types/node":"^18.0.0","eslint":"^8.9.0","prettier":"~2.7.1","typescript":"~4.8.0","rimraf":"^3.0.2","@types/lodash":"^4.14.182","fs-extra":"^10.0.0","@types/fs-extra":"^8.1.0","ts-node":"^10.7.0"}}

package/dist/static/paginateContent.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginateContent = void 0;
+exports.paginateContent = `
+import {
+  getPagedAsyncIterator,
+  PagedAsyncIterableIterator,
+  PagedResult
+} from "@azure/core-paging";
+import {
+  Client,
+  createRestError,
+  PathUncheckedResponse
+} from "@azure-rest/core-client";
+
+/**
+ * Helper type to extract the type of an array
+ */
+export type GetArrayType<T> = T extends Array<infer TData> ? TData : never;
+
+/**
+ * The type of a custom function that defines how to get a page and a link to the next one if any.
+ */
+export type GetPage<TPage> = (
+  pageLink: string,
+  maxPageSize?: number
+) => Promise<{
+  page: TPage;
+  nextPageLink?: string;
+}>;
+
+/**
+ * Options for the paging helper
+ */
+export interface PagingOptions<TResponse> {
+  /**
+   * Custom function to extract pagination details for crating the PagedAsyncIterableIterator
+  */
+  customGetPage?: GetPage<PaginateReturn<TResponse>[]>
+}
+
+/**
+ * Helper type to infer the Type of the paged elements from the response type
+ * This type is generated based on the swagger information for x-ms-pageable
+ * specifically on the itemName property which indicates the property of the response
+ * where the page items are found. The default value is \`value\`.
+ * This type will allow us to provide strongly typed Iterator based on the response we get as second parameter
+ */
+ export type PaginateReturn<TResult> = TResult extends  {{#each itemNames}}
+ {
+ 
+  body: { {{this}}?: infer TPage } 
+  
+} {{#if @last }}{{else}} | {{/if}}
+{{/each}}
+  ? GetArrayType<TPage>
+  : Array<unknown>;
+  
+  /**
+ * Helper to paginate results from an initial response that follows the specification of Autorest \`x-ms-pageable\` extension
+ * @param client - Client to use for sending the next page requests
+ * @param initialResponse - Initial response containing the nextLink and current page of elements
+ * @param customGetPage - Optional - Function to define how to extract the page and next link to be used to paginate the results
+ * @returns - PagedAsyncIterableIterator to iterate the elements
+ */
+   export function paginate<TResponse extends PathUncheckedResponse>(
+    client: Client,
+    initialResponse: TResponse,
+    options: PagingOptions<TResponse> = {}
+  ): PagedAsyncIterableIterator<PaginateReturn<TResponse>> {
+    // Extract element type from initial response
+    type TElement = PaginateReturn<TResponse>;
+    let firstRun = true;
+    {{#if isComplexPaging}}
+    // We need to check the response for success before trying to inspect it looking for
+  // the properties to use for nextLink and itemName
+  checkPagingRequest(initialResponse);
+  const { itemName, nextLinkName } = getPaginationProperties(initialResponse);
+  {{else}}
+  const itemName = {{ quoteWrap itemNames }};
+  const nextLinkName = {{quoteWrap nextLinkNames}};
+  {{/if}}
+  const { customGetPage } = options;
+  const pagedResult: PagedResult<TElement[]> = {
+    firstPageLink: "",
+    getPage:
+      typeof customGetPage === "function"
+        ? customGetPage
+        : async (pageLink: string) => {
+            const result = firstRun
+              ? initialResponse
+              : await client.pathUnchecked(pageLink).get();
+            firstRun = false;
+            checkPagingRequest(result);
+            const nextLink = getNextLink(result.body, nextLinkName);
+            const values = getElements<TElement>(result.body, itemName);
+            return {
+              page: values,
+              nextPageLink: nextLink
+            };
+          }
+  };
+
+  return getPagedAsyncIterator(pagedResult);
+}
+
+/**
+ * Gets for the value of nextLink in the body
+ */
+function getNextLink(body: unknown, nextLinkName?: string): string | undefined {
+   if (!nextLinkName) {
+    return undefined;
+  }
+
+  const nextLink = (body as Record<string, unknown>)[nextLinkName];
+
+  if (typeof nextLink !== "string" && typeof nextLink !== "undefined") {
+    throw new Error(
+      \`Body Property \${nextLinkName} should be a string or undefined\`
+    );
+  }
+
+  return nextLink;
+}
+
+/**
+ * Gets the elements of the current request in the body.
+ */
+function getElements<T = unknown>(body: unknown, itemName: string): T[] {
+  const value = (body as Record<string, unknown>)[itemName] as T[];
+
+  // value has to be an array according to the x-ms-pageable extension.
+  // The fact that this must be an array is used above to calculate the
+  // type of elements in the page in PaginateReturn
+  if (!Array.isArray(value)) {
+    throw new Error(
+      \`Couldn't paginate response\\n Body doesn't contain an array property with name: \${itemName}\`
+    );
+  }
+
+  return value ?? [];
+}
+
+/**
+ * Checks if a request failed
+ */
+function checkPagingRequest(response: PathUncheckedResponse): void {
+  const Http2xxStatusCodes = [
+    "200",
+    "201",
+    "202",
+    "203",
+    "204",
+    "205",
+    "206",
+    "207",
+    "208",
+    "226"
+  ];
+  if (!Http2xxStatusCodes.includes(response.status)) {
+    throw createRestError(
+      \`Pagination failed with unexpected statusCode \${response.status}\`,
+      response
+    );
+  }
+}
+
+{{#if isComplexPaging}}
+/**
+ * Extracts the itemName and nextLinkName from the initial response to use them for pagination
+ */
+function getPaginationProperties(initialResponse: PathUncheckedResponse) {
+  // Build a set with the passed custom nextLinkNames
+  const nextLinkNames = new Set([{{ quoteWrap nextLinkNames }}]);
+
+  // Build a set with the passed custom set of itemNames
+  const itemNames = new Set([{{ quoteWrap itemNames }}]);
+
+  let nextLinkName: string | undefined;
+  let itemName: string | undefined;
+
+  for (const name of nextLinkNames) {
+    const nextLink = (initialResponse.body as Record<string, unknown>)[
+      name
+    ] as string;
+    if (nextLink) {
+      nextLinkName = name;
+      break;
+    }
+  }
+
+  for (const name of itemNames) {
+    const item = (initialResponse.body as Record<string, unknown>)[
+      name
+    ] as string;
+    if (item) {
+      itemName = name;
+      break;
+    }
+  }
+
+  if (!itemName) {
+    throw new Error(
+      \`Couldn't paginate response\\n Body doesn't contain an array property with name: \${[
+        ...itemNames
+      ].join(" OR ")}\`
+    );
+  }
+
+  return { itemName, nextLinkName };
+}
+{{/if}}
+`;
+//# sourceMappingURL=paginateContent.js.map

package/dist/static/paginateContent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paginateContent.js","sourceRoot":"","sources":["../../src/static/paginateContent.ts"],"names":[],"mappings":";;;AAAa,QAAA,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiN9B,CAAC"}

package/dist/static/pollingContent.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pollingContent = void 0;
+exports.pollingContent = `
+import { Client, HttpResponse } from "@azure-rest/core-client";
+{{#if useLegacyLro}}
+import {
+  LongRunningOperation,
+  LroEngine,
+  LroEngineOptions,
+  LroResponse,
+  PollerLike,
+  PollOperationState
+} from "@azure/core-lro";
+{{else}}
+import {
+  CreateHttpPollerOptions,
+  LongRunningOperation,
+  LroResponse,
+  OperationState,
+  SimplePollerLike,
+  createHttpPoller
+} from "@azure/core-lro";
+{{/if}}
+/**
+ * Helper function that builds a Poller object to help polling a long running operation.
+ * @param client - Client to use for sending the request to get additional pages.
+ * @param initialResponse - The initial response.
+ * @param options - Options to set a resume state or custom polling interval.
+ * @returns - A poller object to poll for operation state updates and eventually get the final response.
+ */
+export {{#unless useLegacyLro}}async {{/unless}}function getLongRunningPoller<TResult extends HttpResponse>(
+  client: Client,
+  initialResponse: TResult,
+  {{#if useLegacyLro}}
+  options: LroEngineOptions<TResult, PollOperationState<TResult>> = {}
+  ): PollerLike<PollOperationState<TResult>, TResult> {
+    {{else}}
+    options: CreateHttpPollerOptions<TResult, OperationState<TResult>> = {}
+    ): Promise<SimplePollerLike<OperationState<TResult>, TResult>> {
+    {{/if}}  
+    const poller: LongRunningOperation<TResult> = {
+    requestMethod: initialResponse.request.method,
+    requestPath: initialResponse.request.url,
+    sendInitialRequest: async () => {
+      // In the case of Rest Clients we are building the LRO poller object from a response that's the reason
+      // we are not triggering the initial request here, just extracting the information from the
+      // response we were provided.
+      return getLroResponse(initialResponse);
+    },
+    sendPollRequest: async path => {
+      // This is the callback that is going to be called to poll the service
+      // to get the latest status. We use the client provided and the polling path
+      // which is an opaque URL provided by caller, the service sends this in one of the following headers: operation-location, azure-asyncoperation or location
+      // depending on the lro pattern that the service implements. If non is provided we default to the initial path.
+      const response = await client
+        .pathUnchecked(path ?? initialResponse.request.url)
+        .get();
+      const lroResponse = getLroResponse(response as TResult);
+      lroResponse.rawResponse.headers["x-ms-original-url"] =
+        initialResponse.request.url;
+      return lroResponse;
+    }
+  };
+
+  {{#if useLegacyLro}}
+  return new LroEngine(poller, options);
+  {{else}}
+  options.resolveOnUnsuccessful = options.resolveOnUnsuccessful ?? true;
+  return await createHttpPoller(poller, options);
+  {{/if}}
+}
+
+/**
+ * Converts a Rest Client response to a response that the LRO implementation understands
+ * @param response - a rest client http response
+ * @returns - An LRO response that the LRO implementation understands
+ */
+function getLroResponse<TResult extends HttpResponse>(
+  response: TResult
+): LroResponse<TResult> {
+  if (Number.isNaN(response.status)) {
+    throw new TypeError(
+      \`Status code of the response is not a number. Value: \${response.status}\`
+    );
+  }
+
+  return {
+    flatResponse: response,
+    rawResponse: {
+      ...response,
+      statusCode: Number.parseInt(response.status),
+      body: response.body
+    }
+  };
+}
+`;
+//# sourceMappingURL=pollingContent.js.map

package/dist/static/pollingContent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pollingContent.js","sourceRoot":"","sources":["../../src/static/pollingContent.ts"],"names":[],"mappings":";;;AAAa,QAAA,cAAc,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6F7B,CAAC"}

package/dist/static/serializeHelper.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTsvCollectionContent = exports.buildSsvCollectionContent = exports.buildPipeCollectionContent = exports.buildMultiCollectionContent = void 0;
+exports.buildMultiCollectionContent = `
+export function buildMultiCollection(
+  queryParameters: string[],
+  parameterName: string
+) {
+  return queryParameters
+    .map((item, index) => {
+      if (index === 0) {
+        return item;
+      }
+      return \`\${parameterName}=\${item}\`;
+    })
+    .join("&");
+}`;
+exports.buildPipeCollectionContent = `
+export function buildPipeCollection(queryParameters: string[]): string {
+  return queryParameters.join("|");
+}`;
+exports.buildSsvCollectionContent = `
+export function buildSsvCollection(queryParameters: string[]): string {
+  return queryParameters.join(" ");
+}`;
+exports.buildTsvCollectionContent = `
+export function buildTsvCollection(queryParameters: string[]) {
+  return queryParameters.join("\\t");
+}`;
+//# sourceMappingURL=serializeHelper.js.map

package/dist/static/serializeHelper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializeHelper.js","sourceRoot":"","sources":["../../src/static/serializeHelper.ts"],"names":[],"mappings":";;;AAAa,QAAA,2BAA2B,GAAG;;;;;;;;;;;;;EAazC,CAAC;AAEU,QAAA,0BAA0B,GAAG;;;EAGxC,CAAC;AAEU,QAAA,yBAAyB,GAAG;;;EAGvC,CAAC;AAEU,QAAA,yBAAyB,GAAG;;;EAGvC,CAAC"}

package/dist/test/buildEnvFile.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEnvBrowserFile = exports.buildEnvFile = void 0;
+// @ts-ignore: to fix the handlebars issue
+const handlebars_1 = require("handlebars");
+const template_js_1 = require("./template.js");
+function buildEnvFile(model) {
+    var _a;
+    const generateTest = Boolean((_a = model.options) === null || _a === void 0 ? void 0 : _a.generateTest);
+    if (!generateTest) {
+        return;
+    }
+    return {
+        path: "test/public/utils/env.ts",
+        content: handlebars_1.default.compile(template_js_1.envContent, { noEscape: true })({})
+    };
+}
+exports.buildEnvFile = buildEnvFile;
+function buildEnvBrowserFile(model) {
+    var _a;
+    const generateTest = Boolean((_a = model.options) === null || _a === void 0 ? void 0 : _a.generateTest);
+    if (!generateTest) {
+        return;
+    }
+    return {
+        path: "test/public/utils/env.browser.ts",
+        content: handlebars_1.default.compile("", { noEscape: true })({})
+    };
+}
+exports.buildEnvBrowserFile = buildEnvBrowserFile;
+//# sourceMappingURL=buildEnvFile.js.map

package/dist/test/buildEnvFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildEnvFile.js","sourceRoot":"","sources":["../../src/test/buildEnvFile.ts"],"names":[],"mappings":";;;AAAA,0CAA0C;AAC1C,2CAA6B;AAC7B,+CAA2C;AAG3C,SAAgB,YAAY,CAAC,KAAe;;IAC1C,MAAM,YAAY,GAAG,OAAO,CAAC,MAAA,KAAK,CAAC,OAAO,0CAAE,YAAY,CAAC,CAAC;IAC1D,IAAI,CAAC,YAAY,EAAE;QACjB,OAAO;KACR;IACD,OAAO;QACL,IAAI,EAAE,0BAA0B;QAChC,OAAO,EAAE,oBAAG,CAAC,OAAO,CAAC,wBAAU,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;KACzD,CAAC;AACJ,CAAC;AATD,oCASC;AAED,SAAgB,mBAAmB,CAAC,KAAe;;IACjD,MAAM,YAAY,GAAG,OAAO,CAAC,MAAA,KAAK,CAAC,OAAO,0CAAE,YAAY,CAAC,CAAC;IAC1D,IAAI,CAAC,YAAY,EAAE;QACjB,OAAO;KACR;IACD,OAAO;QACL,IAAI,EAAE,kCAAkC;QACxC,OAAO,EAAE,oBAAG,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;KACjD,CAAC;AACJ,CAAC;AATD,kDASC"}

package/dist/test/buildKarmaConfig.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildKarmaConfigFile = void 0;
+// @ts-ignore: to fix the handlebars issue
+const handlebars_1 = require("handlebars");
+const template_js_1 = require("./template.js");
+function buildKarmaConfigFile(model) {
+    var _a;
+    const generateTest = Boolean((_a = model.options) === null || _a === void 0 ? void 0 : _a.generateTest);
+    if (!generateTest) {
+        return;
+    }
+    return {
+        path: "karma.conf.js",
+        content: handlebars_1.default.compile(template_js_1.karmaConfig, { noEscape: true })({})
+    };
+}
+exports.buildKarmaConfigFile = buildKarmaConfigFile;
+//# sourceMappingURL=buildKarmaConfig.js.map

package/dist/test/buildKarmaConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildKarmaConfig.js","sourceRoot":"","sources":["../../src/test/buildKarmaConfig.ts"],"names":[],"mappings":";;;AAAA,0CAA0C;AAC1C,2CAA6B;AAE7B,+CAA4C;AAE5C,SAAgB,oBAAoB,CAAC,KAAe;;IAClD,MAAM,YAAY,GAAG,OAAO,CAAC,MAAA,KAAK,CAAC,OAAO,0CAAE,YAAY,CAAC,CAAC;IAC1D,IAAI,CAAC,YAAY,EAAE;QACjB,OAAO;KACR;IACD,OAAO;QACL,IAAI,EAAE,eAAe;QACrB,OAAO,EAAE,oBAAG,CAAC,OAAO,CAAC,yBAAW,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;KAC1D,CAAC;AACJ,CAAC;AATD,oDASC"}

package/dist/test/buildRecordedClient.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRecordedClientFile = void 0;
+// @ts-ignore: to fix the handlebars issue
+const handlebars_1 = require("handlebars");
+const template_js_1 = require("./template.js");
+function buildRecordedClientFile(model) {
+    var _a;
+    const generateTest = Boolean((_a = model.options) === null || _a === void 0 ? void 0 : _a.generateTest);
+    if (!generateTest) {
+        return;
+    }
+    const recordedClientFileContents = handlebars_1.default.compile(template_js_1.recordedClientContent, {
+        noEscape: true
+    });
+    return {
+        path: "test/public/utils/recordedClient.ts",
+        content: recordedClientFileContents({})
+    };
+}
+exports.buildRecordedClientFile = buildRecordedClientFile;
+//# sourceMappingURL=buildRecordedClient.js.map

package/dist/test/buildRecordedClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildRecordedClient.js","sourceRoot":"","sources":["../../src/test/buildRecordedClient.ts"],"names":[],"mappings":";;;AAAA,0CAA0C;AAC1C,2CAA6B;AAE7B,+CAAsD;AAEtD,SAAgB,uBAAuB,CAAC,KAAe;;IACrD,MAAM,YAAY,GAAG,OAAO,CAAC,MAAA,KAAK,CAAC,OAAO,0CAAE,YAAY,CAAC,CAAC;IAC1D,IAAI,CAAC,YAAY,EAAE;QACjB,OAAO;KACR;IACD,MAAM,0BAA0B,GAAG,oBAAG,CAAC,OAAO,CAAC,mCAAqB,EAAE;QACpE,QAAQ,EAAE,IAAI;KACf,CAAC,CAAC;IACH,OAAO;QACL,IAAI,EAAE,qCAAqC;QAC3C,OAAO,EAAE,0BAA0B,CAAC,EAAE,CAAC;KACxC,CAAC;AACJ,CAAC;AAZD,0DAYC"}

package/dist/test/buildSampleTest.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSampleTest = void 0;
+// @ts-ignore: to fix the handlebars issue
+const handlebars_1 = require("handlebars");
+const template_js_1 = require("./template.js");
+function buildSampleTest(model) {
+    var _a;
+    const generateTest = Boolean((_a = model.options) === null || _a === void 0 ? void 0 : _a.generateTest);
+    if (!generateTest) {
+        return;
+    }
+    return {
+        path: "test/public/sampleTest.spec.ts",
+        content: handlebars_1.default.compile(template_js_1.sampleTestContent, { noEscape: true })({})
+    };
+}
+exports.buildSampleTest = buildSampleTest;
+//# sourceMappingURL=buildSampleTest.js.map

package/dist/test/buildSampleTest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildSampleTest.js","sourceRoot":"","sources":["../../src/test/buildSampleTest.ts"],"names":[],"mappings":";;;AAAA,0CAA0C;AAC1C,2CAA6B;AAC7B,+CAAkD;AAGlD,SAAgB,eAAe,CAAC,KAAe;;IAC7C,MAAM,YAAY,GAAG,OAAO,CAAC,MAAA,KAAK,CAAC,OAAO,0CAAE,YAAY,CAAC,CAAC;IAC1D,IAAI,CAAC,YAAY,EAAE;QACjB,OAAO;KACR;IACD,OAAO;QACL,IAAI,EAAE,gCAAgC;QACtC,OAAO,EAAE,oBAAG,CAAC,OAAO,CAAC,+BAAiB,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;KAChE,CAAC;AACJ,CAAC;AATD,0CASC"}