@azure-tools/typespec-ts 0.53.3 → 0.54.0

package/dist/src/rlc-common/metadata/packageJson/packageCommon.d.ts

@@ -0,0 +1,64 @@
+export interface PackageCommonInfoConfig {
+    name: string;
+    nameWithoutScope?: string;
+    version: string;
+    description: string;
+    moduleKind: "esm" | "cjs";
+    withTests: boolean;
+    withSamples: boolean;
+    exports?: Record<string, any>;
+    dependencies?: Record<string, string>;
+    azureArm?: boolean;
+    isModularLibrary?: boolean;
+    azureSdkForJs?: boolean;
+    /**
+     * When true, generates React Native build targets (dist/react-native, exports condition).
+     * Defaults to false. Only applicable when azureSdkForJs is true.
+     */
+    generateReactNativeTarget?: boolean;
+}
+/**
+ * Common package.json config for a package.
+ */
+export declare function getPackageCommonInfo(config: PackageCommonInfoConfig): {
+    main?: string | undefined;
+    module?: string | undefined;
+    types?: string | undefined;
+    name: string;
+    version: string;
+    description: string;
+    engines: {
+        node: string;
+    };
+    sideEffects: boolean;
+    autoPublish: boolean;
+};
+export declare const commonPackageDependencies: {
+    tslib: string;
+};
+export declare function getCommonPackageDevDependencies(config: PackageCommonInfoConfig): {
+    tshy?: undefined;
+    "@types/node": string;
+    eslint: string;
+    typescript: string;
+} | {
+    tshy: string;
+    "@types/node": string;
+    eslint: string;
+    typescript: string;
+};
+/**
+ * Resolve source-level exports to dist-level exports for warp.
+ * Converts { ".": "./src/index.ts" } to the nested condition map with
+ * browser/import/require conditions pointing to dist/ paths.
+ */
+export declare function resolveWarpExports(sourceExports?: Record<string, any>, includeReactNative?: boolean): Record<string, any>;
+export declare function getTshyConfig(config: PackageCommonInfoConfig): Record<string, any>;
+export declare function getCommonPackageScripts(): {
+    clean: string;
+    "extract-api": string;
+    pack: string;
+    lint: string;
+    "lint:fix": string;
+};
+//# sourceMappingURL=packageCommon.d.ts.map

package/dist/src/rlc-common/metadata/packageJson/packageCommon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packageCommon.d.ts","sourceRoot":"","sources":["../../../../../src/rlc-common/metadata/packageJson/packageCommon.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,KAAK,GAAG,KAAK,CAAC;IAC1B,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;OAGG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACrC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,uBAAuB;;;;;;;;;;;;EAcnE;AAED,eAAO,MAAM,yBAAyB;;CAErC,CAAC;AAEF,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,uBAAuB;;;;;;;;;;EAQhC;AA+GD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACnC,kBAAkB,CAAC,EAAE,OAAO,GAC3B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CA8CrB;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,uBAAuB,uBAmB5D;AAED,wBAAgB,uBAAuB;;;;;;EAWtC"}

package/dist/src/rlc-common/metadata/packageJson/packageCommon.js

@@ -0,0 +1,183 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+/**
+ * Common package.json config for a package.
+ */
+export function getPackageCommonInfo(config) {
+    const { name, version, description } = config;
+    return {
+        name,
+        version,
+        description,
+        engines: {
+            node: ">=20.0.0"
+        },
+        sideEffects: false,
+        autoPublish: false,
+        ...getEntryPointInformation(config)
+    };
+}
+export const commonPackageDependencies = {
+    tslib: "^2.6.2"
+};
+export function getCommonPackageDevDependencies(config) {
+    return {
+        "@types/node": "^20.0.0",
+        eslint: "^9.9.0",
+        typescript: "~5.8.2",
+        ...getEsmDevDependencies(config)
+    };
+}
+function getEsmDevDependencies({ moduleKind, azureSdkForJs }) {
+    if (moduleKind !== "esm") {
+        return {};
+    }
+    // Azure monorepo packages use warp (invoked via dev-tool), no tshy needed
+    if (azureSdkForJs) {
+        return {};
+    }
+    return {
+        tshy: "^2.0.0"
+    };
+}
+function getEntryPointInformation(config) {
+    return {
+        ...getCjsEntrypointInformation(config),
+        ...getEsmEntrypointInformation(config)
+    };
+}
+function getCjsEntrypointInformation({ name, nameWithoutScope, moduleKind, withTests, withSamples }) {
+    if (moduleKind !== "cjs") {
+        return;
+    }
+    const types = withTests || withSamples
+        ? `./types/src/${nameWithoutScope !== null && nameWithoutScope !== void 0 ? nameWithoutScope : name}.d.ts`
+        : `./types/${nameWithoutScope !== null && nameWithoutScope !== void 0 ? nameWithoutScope : name}.d.ts`;
+    const main = withTests || withSamples ? "dist/src/index.js" : "dist/index.js";
+    return {
+        main,
+        module: withTests || withSamples
+            ? "./dist-esm/src/index.js"
+            : "./dist-esm/index.js",
+        types
+    };
+}
+function getEsmEntrypointInformation(config) {
+    if (config.moduleKind !== "esm") {
+        return;
+    }
+    // Azure monorepo packages use warp instead of tshy
+    if (config.azureSdkForJs) {
+        const result = {
+            type: "module",
+            main: "./dist/commonjs/index.js",
+            module: "./dist/esm/index.js",
+            types: "./dist/commonjs/index.d.ts",
+            browser: "./dist/browser/index.js",
+            imports: {
+                "#platform/*": {
+                    browser: "./src/*-browser.mts",
+                    default: "./src/*.ts"
+                }
+            },
+            exports: resolveWarpExports(config.exports, config.generateReactNativeTarget)
+        };
+        if (config.generateReactNativeTarget) {
+            result["react-native"] = "./dist/react-native/index.js";
+            result["imports"]["#platform/*"]["react-native"] = "./src/*-react-native.mts";
+            // Reorder so react-native comes before default
+            const importsEntry = result["imports"]["#platform/*"];
+            result["imports"]["#platform/*"] = {
+                browser: importsEntry["browser"],
+                "react-native": importsEntry["react-native"],
+                default: importsEntry["default"]
+            };
+        }
+        return result;
+    }
+    // Non-monorepo packages use tshy which manages polyfill resolution
+    // via esmDialects — do NOT add imports here.
+    const result = {
+        tshy: getTshyConfig(config),
+        type: "module",
+        browser: "./dist/browser/index.js"
+    };
+    if (config.generateReactNativeTarget) {
+        result["react-native"] = "./dist/react-native/index.js";
+    }
+    return result;
+}
+/**
+ * Resolve source-level exports to dist-level exports for warp.
+ * Converts { ".": "./src/index.ts" } to the nested condition map with
+ * browser/import/require conditions pointing to dist/ paths.
+ */
+export function resolveWarpExports(sourceExports, includeReactNative) {
+    const exports = {};
+    const allExports = {
+        "./package.json": "./package.json",
+        ".": "./src/index.ts",
+        ...sourceExports
+    };
+    for (const [subpath, sourcePath] of Object.entries(allExports)) {
+        // Pass-through entries (e.g. "./package.json": "./package.json")
+        if (!/\.ts$/.test(sourcePath)) {
+            exports[subpath] = sourcePath;
+            continue;
+        }
+        // Convert source path to dist path: "./src/foo/index.ts" -> "foo/index"
+        const relPath = sourcePath.replace(/^\.\/src\//, "").replace(/\.ts$/, "");
+        const exportEntry = {
+            browser: {
+                types: `./dist/browser/${relPath}.d.ts`,
+                default: `./dist/browser/${relPath}.js`
+            }
+        };
+        if (includeReactNative) {
+            exportEntry["react-native"] = {
+                types: `./dist/react-native/${relPath}.d.ts`,
+                default: `./dist/react-native/${relPath}.js`
+            };
+        }
+        exportEntry["import"] = {
+            types: `./dist/esm/${relPath}.d.ts`,
+            default: `./dist/esm/${relPath}.js`
+        };
+        exportEntry["require"] = {
+            types: `./dist/commonjs/${relPath}.d.ts`,
+            default: `./dist/commonjs/${relPath}.js`
+        };
+        exports[subpath] = exportEntry;
+    }
+    return exports;
+}
+export function getTshyConfig(config) {
+    const { exports = {} } = config;
+    const esmDialects = config.generateReactNativeTarget
+        ? ["browser", "react-native"]
+        : ["browser"];
+    const tshyConfig = {
+        exports: {
+            "./package.json": "./package.json",
+            ".": "./src/index.ts",
+            ...exports
+        },
+        dialects: ["esm", "commonjs"],
+        esmDialects,
+        selfLink: false
+    };
+    if (config.azureSdkForJs) {
+        tshyConfig["project"] = "../../../tsconfig.src.build.json";
+    }
+    return tshyConfig;
+}
+export function getCommonPackageScripts() {
+    return {
+        clean: "rimraf --glob dist dist-browser dist-esm test-dist temp types *.tgz *.log",
+        "extract-api": "rimraf review && mkdirp ./review && api-extractor run --local",
+        pack: "npm pack 2>&1",
+        lint: "eslint package.json api-extractor.json src",
+        "lint:fix": "eslint package.json api-extractor.json src --fix --fix-type [problem,suggestion]"
+    };
+}
+//# sourceMappingURL=packageCommon.js.map

package/dist/src/rlc-common/metadata/packageJson/packageCommon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"packageCommon.js","sourceRoot":"","sources":["../../../../../src/rlc-common/metadata/packageJson/packageCommon.ts"],"names":[],"mappings":"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"}

package/dist/src/rlc-common/metadata/utils.d.ts

@@ -0,0 +1,3 @@
+import { RLCModel } from "../interfaces.js";
+export declare function getPackageName(model: RLCModel): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/rlc-common/metadata/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/rlc-common/metadata/utils.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAEtD"}

package/dist/src/rlc-common/metadata/utils.js

@@ -0,0 +1,7 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export function getPackageName(model) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = model.options) === null || _a === void 0 ? void 0 : _a.packageDetails) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : model.libraryName;
+}
+//# sourceMappingURL=utils.js.map

package/dist/src/rlc-common/metadata/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/rlc-common/metadata/utils.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAIlC,MAAM,UAAU,cAAc,CAAC,KAAe;;IAC5C,OAAO,MAAA,MAAA,MAAA,KAAK,CAAC,OAAO,0CAAE,cAAc,0CAAE,IAAI,mCAAI,KAAK,CAAC,WAAW,CAAC;AAClE,CAAC"}

package/dist/src/rlc-common/static/paginateContent.d.ts

@@ -0,0 +1,2 @@
+export declare const paginateContent = "\nimport type { Client, PathUncheckedResponse } from \"@azure-rest/core-client\";\nimport { createRestError } from \"@azure-rest/core-client\";\n\n/**\n * returns an async iterator that iterates over results. It also has a `byPage`\n * method that returns pages of items at once.\n *\n * @param pagedResult - an object that specifies how to get pages.\n * @returns a paged async iterator that iterates over results.\n */\nfunction getPagedAsyncIterator<\n  TElement,\n  TPage = TElement[],\n  TPageSettings = PageSettings,\n  TLink = string,\n>(\n  pagedResult: PagedResult<TPage, TPageSettings, TLink>,\n): PagedAsyncIterableIterator<TElement, TPage, TPageSettings> {\n  const iter = getItemAsyncIterator<TElement, TPage, TLink, TPageSettings>(pagedResult);\n  return {\n    next() {\n      return iter.next();\n    },\n    [Symbol.asyncIterator]() {\n      return this;\n    },\n    byPage:\n      pagedResult?.byPage ??\n      (((settings?: PageSettings) => {\n        const { continuationToken } = settings ?? {};\n        return getPageAsyncIterator(pagedResult, {\n          pageLink: continuationToken as unknown as TLink | undefined,\n        });\n      }) as unknown as (settings?: TPageSettings) => AsyncIterableIterator<TPage>),\n  };\n}\n\nasync function* getItemAsyncIterator<TElement, TPage, TLink, TPageSettings>(\n  pagedResult: PagedResult<TPage, TPageSettings, TLink>,\n): AsyncIterableIterator<TElement> {\n  const pages = getPageAsyncIterator(pagedResult);\n  const firstVal = await pages.next();\n  // if the result does not have an array shape, i.e. TPage = TElement, then we return it as is\n  if (!Array.isArray(firstVal.value)) {\n    // can extract elements from this page\n    const { toElements } = pagedResult;\n    if (toElements) {\n      yield* toElements(firstVal.value) as TElement[];\n      for await (const page of pages) {\n        yield* toElements(page) as TElement[];\n      }\n    } else {\n      yield firstVal.value;\n      // `pages` is of type `AsyncIterableIterator<TPage>` but TPage = TElement in this case\n      yield* pages as unknown as AsyncIterableIterator<TElement>;\n    }\n  } else {\n    yield* firstVal.value;\n    for await (const page of pages) {\n      // pages is of type `AsyncIterableIterator<TPage>` so `page` is of type `TPage`. In this branch,\n      // it must be the case that `TPage = TElement[]`\n      yield* page as unknown as TElement[];\n    }\n  }\n}\n\nasync function* getPageAsyncIterator<TPage, TLink, TPageSettings>(\n  pagedResult: PagedResult<TPage, TPageSettings, TLink>,\n  options: {\n    pageLink?: TLink;\n  } = {},\n): AsyncIterableIterator<TPage> {\n  const { pageLink } = options;\n  let response = await pagedResult.getPage(pageLink ?? pagedResult.firstPageLink);\n  if (!response) {\n    return;\n  }\n  yield response.page;\n  while (response.nextPageLink) {\n    response = await pagedResult.getPage(response.nextPageLink);\n    if (!response) {\n      return;\n    }\n    yield response.page;\n  }\n}\n\n/**\n * An interface that tracks the settings for paged iteration\n */\nexport interface PageSettings {\n  /**\n   * The token that keeps track of where to continue the iterator\n   */\n  continuationToken?: string;\n}\n\n/**\n * An interface that allows async iterable iteration both to completion and by page.\n */\nexport interface PagedAsyncIterableIterator<\n  TElement,\n  TPage = TElement[],\n  TPageSettings = PageSettings,\n> {\n  /**\n   * The next method, part of the iteration protocol\n   */\n  next(): Promise<IteratorResult<TElement>>;\n  /**\n   * The connection to the async iterator, part of the iteration protocol\n   */\n  [Symbol.asyncIterator](): PagedAsyncIterableIterator<TElement, TPage, TPageSettings>;\n  /**\n   * Return an AsyncIterableIterator that works a page at a time\n   */\n  byPage: (settings?: TPageSettings) => AsyncIterableIterator<TPage>;\n}\n\n/**\n * An interface that describes how to communicate with the service.\n */\ninterface PagedResult<TPage, TPageSettings = PageSettings, TLink = string> {\n  /**\n   * Link to the first page of results.\n   */\n  firstPageLink: TLink;\n  /**\n   * A method that returns a page of results.\n   */\n  getPage: (\n    pageLink: TLink,\n  ) => Promise<{ page: TPage; nextPageLink?: TLink } | undefined>;\n  /**\n   * a function to implement the `byPage` method on the paged async iterator.\n   */\n  byPage?: (settings?: TPageSettings) => AsyncIterableIterator<TPage>;\n\n  /**\n   * A function to extract elements from a page.\n   */\n  toElements?: (page: TPage) => unknown[];\n}\n\n/**\n * Helper type to extract the type of an array\n */\nexport type GetArrayType<T> = T extends Array<infer TData> ? TData : never;\n\n/**\n * The type of a custom function that defines how to get a page and a link to the next one if any.\n */\nexport type GetPage<TPage> = (\n  pageLink: string,\n) => Promise<{\n  page: TPage;\n  nextPageLink?: string;\n}>;\n\n/**\n * Options for the paging helper\n */\nexport interface PagingOptions<TResponse> {\n  /**\n   * Custom function to extract pagination details for crating the PagedAsyncIterableIterator\n  */\n  customGetPage?: GetPage<PaginateReturn<TResponse>[]>\n}\n\n/**\n * Helper type to infer the Type of the paged elements from the response type\n * This type is generated based on the swagger information for x-ms-pageable\n * specifically on the itemName property which indicates the property of the response\n * where the page items are found. The default value is `value`.\n * This type will allow us to provide strongly typed Iterator based on the response we get as second parameter\n */\n export type PaginateReturn<TResult> = TResult extends  {{#each itemNames}}\n {\n \n  body: { {{this}}?: infer TPage } \n  \n} {{#if @last }}{{else}} | {{/if}}\n{{/each}}\n  ? GetArrayType<TPage>\n  : Array<unknown>;\n  \n  /**\n * Helper to paginate results from an initial response that follows the specification of Autorest `x-ms-pageable` extension\n * @param client - Client to use for sending the next page requests\n * @param initialResponse - Initial response containing the nextLink and current page of elements\n * @param customGetPage - Optional - Function to define how to extract the page and next link to be used to paginate the results\n * @returns - PagedAsyncIterableIterator to iterate the elements\n */\n   export function paginate<TResponse extends PathUncheckedResponse>(\n    client: Client,\n    initialResponse: TResponse,\n    options: PagingOptions<TResponse> = {}\n  ): PagedAsyncIterableIterator<PaginateReturn<TResponse>> {\n    // Extract element type from initial response\n    type TElement = PaginateReturn<TResponse>;\n    let firstRun = true;\n    {{#if isComplexPaging}}\n    // We need to check the response for success before trying to inspect it looking for\n  // the properties to use for nextLink and itemName\n  checkPagingRequest(initialResponse);\n  const { itemName, nextLinkName } = getPaginationProperties(initialResponse);\n  {{else}}\n  const itemName = {{ quoteWrap itemNames }};\n  const nextLinkName = {{quoteWrap nextLinkNames}};\n  {{/if}}\n  const { customGetPage } = options;\n  const pagedResult: PagedResult<TElement[]> = {\n    firstPageLink: \"\",\n    getPage:\n      typeof customGetPage === \"function\"\n        ? customGetPage\n        : async (pageLink: string) => {\n            const result = firstRun\n              ? initialResponse\n              : await client.pathUnchecked(pageLink).get();\n            firstRun = false;\n            checkPagingRequest(result);\n            const nextLink = getNextLink(result.body, nextLinkName);\n            const values = getElements<TElement>(result.body, itemName);\n            return {\n              page: values,\n              nextPageLink: nextLink\n            };\n          }\n  };\n\n  return getPagedAsyncIterator(pagedResult);\n}\n\n/**\n * Gets for the value of nextLink in the body\n */\nfunction getNextLink(body: unknown, nextLinkName?: string): string | undefined {\n   if (!nextLinkName) {\n    return undefined;\n  }\n\n  const nextLink = (body as Record<string, unknown>)[nextLinkName];\n\n  if (typeof nextLink !== \"string\" && typeof nextLink !== \"undefined\") {\n    throw new Error(\n      `Body Property ${nextLinkName} should be a string or undefined`\n    );\n  }\n\n  return nextLink;\n}\n\n/**\n * Gets the elements of the current request in the body.\n */\nfunction getElements<T = unknown>(body: unknown, itemName: string): T[] {\n  const value = (body as Record<string, unknown>)[itemName] as T[];\n\n  // value has to be an array according to the x-ms-pageable extension.\n  // The fact that this must be an array is used above to calculate the\n  // type of elements in the page in PaginateReturn\n  if (!Array.isArray(value)) {\n    throw new Error(\n      `Couldn't paginate response\\n Body doesn't contain an array property with name: ${itemName}`\n    );\n  }\n\n  return value ?? [];\n}\n\n/**\n * Checks if a request failed\n */\nfunction checkPagingRequest(response: PathUncheckedResponse): void {\n  const Http2xxStatusCodes = [\n    \"200\",\n    \"201\",\n    \"202\",\n    \"203\",\n    \"204\",\n    \"205\",\n    \"206\",\n    \"207\",\n    \"208\",\n    \"226\"\n  ];\n  if (!Http2xxStatusCodes.includes(response.status)) {\n    throw createRestError(\n      `Pagination failed with unexpected statusCode ${response.status}`,\n      response\n    );\n  }\n}\n\n{{#if isComplexPaging}}\n/**\n * Extracts the itemName and nextLinkName from the initial response to use them for pagination\n */\nfunction getPaginationProperties(initialResponse: PathUncheckedResponse) {\n  // Build a set with the passed custom nextLinkNames\n  const nextLinkNames = new Set([{{ quoteWrap nextLinkNames }}]);\n\n  // Build a set with the passed custom set of itemNames\n  const itemNames = new Set([{{ quoteWrap itemNames }}]);\n\n  let nextLinkName: string | undefined;\n  let itemName: string | undefined;\n\n  for (const name of nextLinkNames) {\n    const nextLink = (initialResponse.body as Record<string, unknown>)[\n      name\n    ] as string;\n    if (nextLink) {\n      nextLinkName = name;\n      break;\n    }\n  }\n\n  for (const name of itemNames) {\n    const item = (initialResponse.body as Record<string, unknown>)[\n      name\n    ] as string;\n    if (item) {\n      itemName = name;\n      break;\n    }\n  }\n\n  if (!itemName) {\n    throw new Error(\n      `Couldn't paginate response\\n Body doesn't contain an array property with name: ${[\n        ...itemNames\n      ].join(\" OR \")}`\n    );\n  }\n\n  return { itemName, nextLinkName };\n}\n{{/if}}\n";
+//# sourceMappingURL=paginateContent.d.ts.map

package/dist/src/rlc-common/static/paginateContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paginateContent.d.ts","sourceRoot":"","sources":["../../../../src/rlc-common/static/paginateContent.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe,25UAqV3B,CAAC"}

package/dist/src/rlc-common/static/paginateContent.js

@@ -0,0 +1,345 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+export const paginateContent = `
+import type { Client, PathUncheckedResponse } from "@azure-rest/core-client";
+import { createRestError } from "@azure-rest/core-client";
+
+/**
+ * returns an async iterator that iterates over results. It also has a \`byPage\`
+ * method that returns pages of items at once.
+ *
+ * @param pagedResult - an object that specifies how to get pages.
+ * @returns a paged async iterator that iterates over results.
+ */
+function getPagedAsyncIterator<
+  TElement,
+  TPage = TElement[],
+  TPageSettings = PageSettings,
+  TLink = string,
+>(
+  pagedResult: PagedResult<TPage, TPageSettings, TLink>,
+): PagedAsyncIterableIterator<TElement, TPage, TPageSettings> {
+  const iter = getItemAsyncIterator<TElement, TPage, TLink, TPageSettings>(pagedResult);
+  return {
+    next() {
+      return iter.next();
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    byPage:
+      pagedResult?.byPage ??
+      (((settings?: PageSettings) => {
+        const { continuationToken } = settings ?? {};
+        return getPageAsyncIterator(pagedResult, {
+          pageLink: continuationToken as unknown as TLink | undefined,
+        });
+      }) as unknown as (settings?: TPageSettings) => AsyncIterableIterator<TPage>),
+  };
+}
+
+async function* getItemAsyncIterator<TElement, TPage, TLink, TPageSettings>(
+  pagedResult: PagedResult<TPage, TPageSettings, TLink>,
+): AsyncIterableIterator<TElement> {
+  const pages = getPageAsyncIterator(pagedResult);
+  const firstVal = await pages.next();
+  // if the result does not have an array shape, i.e. TPage = TElement, then we return it as is
+  if (!Array.isArray(firstVal.value)) {
+    // can extract elements from this page
+    const { toElements } = pagedResult;
+    if (toElements) {
+      yield* toElements(firstVal.value) as TElement[];
+      for await (const page of pages) {
+        yield* toElements(page) as TElement[];
+      }
+    } else {
+      yield firstVal.value;
+      // \`pages\` is of type \`AsyncIterableIterator<TPage>\` but TPage = TElement in this case
+      yield* pages as unknown as AsyncIterableIterator<TElement>;
+    }
+  } else {
+    yield* firstVal.value;
+    for await (const page of pages) {
+      // pages is of type \`AsyncIterableIterator<TPage>\` so \`page\` is of type \`TPage\`. In this branch,
+      // it must be the case that \`TPage = TElement[]\`
+      yield* page as unknown as TElement[];
+    }
+  }
+}
+
+async function* getPageAsyncIterator<TPage, TLink, TPageSettings>(
+  pagedResult: PagedResult<TPage, TPageSettings, TLink>,
+  options: {
+    pageLink?: TLink;
+  } = {},
+): AsyncIterableIterator<TPage> {
+  const { pageLink } = options;
+  let response = await pagedResult.getPage(pageLink ?? pagedResult.firstPageLink);
+  if (!response) {
+    return;
+  }
+  yield response.page;
+  while (response.nextPageLink) {
+    response = await pagedResult.getPage(response.nextPageLink);
+    if (!response) {
+      return;
+    }
+    yield response.page;
+  }
+}
+
+/**
+ * An interface that tracks the settings for paged iteration
+ */
+export interface PageSettings {
+  /**
+   * The token that keeps track of where to continue the iterator
+   */
+  continuationToken?: string;
+}
+
+/**
+ * An interface that allows async iterable iteration both to completion and by page.
+ */
+export interface PagedAsyncIterableIterator<
+  TElement,
+  TPage = TElement[],
+  TPageSettings = PageSettings,
+> {
+  /**
+   * The next method, part of the iteration protocol
+   */
+  next(): Promise<IteratorResult<TElement>>;
+  /**
+   * The connection to the async iterator, part of the iteration protocol
+   */
+  [Symbol.asyncIterator](): PagedAsyncIterableIterator<TElement, TPage, TPageSettings>;
+  /**
+   * Return an AsyncIterableIterator that works a page at a time
+   */
+  byPage: (settings?: TPageSettings) => AsyncIterableIterator<TPage>;
+}
+
+/**
+ * An interface that describes how to communicate with the service.
+ */
+interface PagedResult<TPage, TPageSettings = PageSettings, TLink = string> {
+  /**
+   * Link to the first page of results.
+   */
+  firstPageLink: TLink;
+  /**
+   * A method that returns a page of results.
+   */
+  getPage: (
+    pageLink: TLink,
+  ) => Promise<{ page: TPage; nextPageLink?: TLink } | undefined>;
+  /**
+   * a function to implement the \`byPage\` method on the paged async iterator.
+   */
+  byPage?: (settings?: TPageSettings) => AsyncIterableIterator<TPage>;
+
+  /**
+   * A function to extract elements from a page.
+   */
+  toElements?: (page: TPage) => unknown[];
+}
+
+/**
+ * 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,
+) => 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/src/rlc-common/static/paginateContent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paginateContent.js","sourceRoot":"","sources":["../../../../src/rlc-common/static/paginateContent.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,kCAAkC;AAElC,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqV9B,CAAC"}