diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
index 763462fa..43fd5a73 100644
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -9,9 +9,7 @@
"postCreateCommand": "yarn install",
"customizations": {
"vscode": {
- "extensions": [
- "esbenp.prettier-vscode"
- ]
+ "extensions": ["esbenp.prettier-vscode"]
}
}
}
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 11b6afc5..741831b0 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,24 +1,25 @@
name: CI
on:
push:
- branches:
- - main
- pull_request:
- branches:
- - main
- - next
+ branches-ignore:
+ - 'generated'
+ - 'codegen/**'
+ - 'integrated/**'
+ - 'stl-preview-head/**'
+ - 'stl-preview-base/**'
jobs:
lint:
+ timeout-minutes: 10
name: lint
- runs-on: ubuntu-latest
+ runs-on: ${{ github.repository == 'stainless-sdks/stainless-v0-typescript' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }}
steps:
- uses: actions/checkout@v4
- name: Set up Node
uses: actions/setup-node@v4
with:
- node-version: '18'
+ node-version: '20'
- name: Bootstrap
run: ./scripts/bootstrap
@@ -27,8 +28,9 @@ jobs:
run: ./scripts/lint
build:
+ timeout-minutes: 5
name: build
- runs-on: ubuntu-latest
+ runs-on: ${{ github.repository == 'stainless-sdks/stainless-v0-typescript' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }}
permissions:
contents: read
id-token: write
@@ -38,7 +40,7 @@ jobs:
- name: Set up Node
uses: actions/setup-node@v4
with:
- node-version: '18'
+ node-version: '20'
- name: Bootstrap
run: ./scripts/bootstrap
@@ -61,15 +63,16 @@ jobs:
SHA: ${{ github.sha }}
run: ./scripts/utils/upload-artifact.sh
test:
+ timeout-minutes: 10
name: test
- runs-on: ubuntu-latest
+ runs-on: ${{ github.repository == 'stainless-sdks/stainless-v0-typescript' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }}
steps:
- uses: actions/checkout@v4
- name: Set up Node
uses: actions/setup-node@v4
with:
- node-version: '18'
+ node-version: '20'
- name: Bootstrap
run: ./scripts/bootstrap
diff --git a/.github/workflows/release-doctor.yml b/.github/workflows/release-doctor.yml
index ca1efac9..52b2def8 100644
--- a/.github/workflows/release-doctor.yml
+++ b/.github/workflows/release-doctor.yml
@@ -18,4 +18,3 @@ jobs:
run: |
bash ./bin/check-release-environment
env:
-
diff --git a/.release-please-manifest.json b/.release-please-manifest.json
index d7a87356..c5e8a3ed 100644
--- a/.release-please-manifest.json
+++ b/.release-please-manifest.json
@@ -1,3 +1,3 @@
{
- ".": "0.1.0-alpha.1"
+ ".": "0.1.0-alpha.2"
}
diff --git a/.stats.yml b/.stats.yml
index 6bb6654e..5228c5f0 100644
--- a/.stats.yml
+++ b/.stats.yml
@@ -1,4 +1,4 @@
-configured_endpoints: 8
-openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/stainless%2Fstainless-v0-9c4cbbd20ce1628e48129ad8e871b729c3f774c5d1ff4cbc560fca81db611d93.yml
-openapi_spec_hash: e511d8f4716a56182b97d139eb89b68a
-config_hash: 1bee02a0eeb902e1ea32aa032bc70f54
+configured_endpoints: 15
+openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/stainless%2Fstainless-v0-6707704fb4cbc87d367d0813979036b8acbcc7f6eff62f7f5e8b9f016920d3ad.yml
+openapi_spec_hash: 3af7623ae449e42f72c7319fa3f8e387
+config_hash: 28c1ddd1e9bdba67e018459acdfafc5b
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c02a909d..21cd4791 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,48 @@
# Changelog
+## 0.1.0-alpha.2 (2025-05-13)
+
+Full Changelog: [v0.1.0-alpha.1...v0.1.0-alpha.2](https://github.com/stainless-api/stainless-api-typescript/compare/v0.1.0-alpha.1...v0.1.0-alpha.2)
+
+### Features
+
+* **api:** add build compare to v0 ([2e583d1](https://github.com/stainless-api/stainless-api-typescript/commit/2e583d15ebcd52bfe43196fe58dac79f45761e08))
+* **api:** configs ([021eac6](https://github.com/stainless-api/stainless-api-typescript/commit/021eac6182c5f01bf9dd2c31f5277fa6cd159a1b))
+* **api:** enable macos publishing ([77ebd7c](https://github.com/stainless-api/stainless-api-typescript/commit/77ebd7c56b71f35e78921d3376b8daf568e39c50))
+* **api:** manual updates ([118d1d1](https://github.com/stainless-api/stainless-api-typescript/commit/118d1d15878c6737307d4796535a74a8a5fab39a))
+* **api:** manual updates ([41114a1](https://github.com/stainless-api/stainless-api-typescript/commit/41114a19b3bd85fc0cc5ba7a5655275f5ac97b99))
+* **api:** manual updates ([056d6bf](https://github.com/stainless-api/stainless-api-typescript/commit/056d6bf0862e908fddabea49cee3ec4e35985060))
+* **api:** manual updates ([54866aa](https://github.com/stainless-api/stainless-api-typescript/commit/54866aa84f9bf8e27acfc948b94175975af61551))
+* **api:** parent build id ([894f36b](https://github.com/stainless-api/stainless-api-typescript/commit/894f36b21905f492a5354b0a1d87f3f30346fae4))
+* **api:** rename api key ([642780a](https://github.com/stainless-api/stainless-api-typescript/commit/642780a0c31945be6b2186abf07bb24f6d2013c2))
+* **api:** use correct hashes ([df1c791](https://github.com/stainless-api/stainless-api-typescript/commit/df1c791cc9fece7a26b60ea5f17a0b4a5772b289))
+* **client:** add withOptions helper ([e7ec49d](https://github.com/stainless-api/stainless-api-typescript/commit/e7ec49d3c6f8fe87ad5d11c77da697e50fa9e9fb))
+
+
+### Bug Fixes
+
+* **client:** always overwrite when merging headers ([4d180e0](https://github.com/stainless-api/stainless-api-typescript/commit/4d180e0da23b27c22f8e8632a5f842448ac0cdc5))
+* update request schema for Postman webhook ([2c590eb](https://github.com/stainless-api/stainless-api-typescript/commit/2c590eb86e83dcc54d30b3104a2e7de9299c35b6))
+
+
+### Chores
+
+* bump go sdk version ([b7f0264](https://github.com/stainless-api/stainless-api-typescript/commit/b7f02648ab3791d3a566a1d790b17d40dae10e9a))
+* **ci:** add timeout thresholds for CI jobs ([7d94fbd](https://github.com/stainless-api/stainless-api-typescript/commit/7d94fbd1d7173a27d554ff6e4d033e8c76a45e35))
+* **ci:** only use depot for staging repos ([5cd101b](https://github.com/stainless-api/stainless-api-typescript/commit/5cd101b5e1e8088d589f377a637f5a9dd2d6ac34))
+* **client:** drop support for EOL node versions ([8a3c07b](https://github.com/stainless-api/stainless-api-typescript/commit/8a3c07bbf7a0e87abaf0ebf453b2ff33181bf197))
+* **internal:** codegen related update ([d9bd40e](https://github.com/stainless-api/stainless-api-typescript/commit/d9bd40e22f070cbda2d5dad163c50dd1a3ecc369))
+* **internal:** codegen related update ([79c9751](https://github.com/stainless-api/stainless-api-typescript/commit/79c9751e084e40662779c187eedc8720d2ddd291))
+* **internal:** refactor utils ([c033a80](https://github.com/stainless-api/stainless-api-typescript/commit/c033a8026d5757a33ae4e4540e1aac51c861ed37))
+* **internal:** share typescript helpers ([b41cddd](https://github.com/stainless-api/stainless-api-typescript/commit/b41cddd3715e545ad5917ac1328a81fd3ddbe5b1))
+* **package:** remove engines ([c089302](https://github.com/stainless-api/stainless-api-typescript/commit/c08930299ad02892bd6a3714c76ac4969cbb78db))
+* **perf:** faster base64 decoding ([f7b9d5d](https://github.com/stainless-api/stainless-api-typescript/commit/f7b9d5d50fff5205d247d3c5987ad000f08f4f6e))
+
+
+### Documentation
+
+* **readme:** fix typo ([412d6bc](https://github.com/stainless-api/stainless-api-typescript/commit/412d6bc1f9f1816ed3cffd6412572245ce9cc6f2))
+
## 0.1.0-alpha.1 (2025-04-21)
Full Changelog: [v0.0.1-alpha.0...v0.1.0-alpha.1](https://github.com/stainless-api/stainless-api-typescript/compare/v0.0.1-alpha.0...v0.1.0-alpha.1)
diff --git a/README.md b/README.md
index 3e736e00..5fd72cf8 100644
--- a/README.md
+++ b/README.md
@@ -85,7 +85,7 @@ async function main() {
main();
```
-Error codes are as followed:
+Error codes are as follows:
| Status Code | Error Type |
| ----------- | -------------------------- |
@@ -362,7 +362,7 @@ TypeScript >= 4.9 is supported.
The following runtimes are supported:
- Web browsers (Up-to-date Chrome, Firefox, Safari, Edge, and more)
-- Node.js 18 LTS or later ([non-EOL](https://endoflife.date/nodejs)) versions.
+- Node.js 20 LTS or later ([non-EOL](https://endoflife.date/nodejs)) versions.
- Deno v1.28.0 or higher.
- Bun 1.0 or later.
- Cloudflare Workers.
diff --git a/api.md b/api.md
index 52d2a0d3..6a7ae43a 100644
--- a/api.md
+++ b/api.md
@@ -4,11 +4,13 @@ Types:
- ProjectRetrieveResponse
- ProjectUpdateResponse
+- ProjectListResponse
Methods:
- client.projects.retrieve(projectName) -> ProjectRetrieveResponse
- client.projects.update(projectName, { ...params }) -> ProjectUpdateResponse
+- client.projects.list({ ...params }) -> ProjectListResponse
## Branches
@@ -21,6 +23,28 @@ Methods:
- client.projects.branches.create(project, { ...params }) -> ProjectBranch
- client.projects.branches.retrieve(branch, { ...params }) -> ProjectBranch
+## Configs
+
+Types:
+
+- ConfigRetrieveResponse
+- ConfigGuessResponse
+
+Methods:
+
+- client.projects.configs.retrieve(project, { ...params }) -> ConfigRetrieveResponse
+- client.projects.configs.guess(project, { ...params }) -> ConfigGuessResponse
+
+## Snippets
+
+Types:
+
+- SnippetCreateRequestResponse
+
+Methods:
+
+- client.projects.snippets.createRequest(projectName, { ...params }) -> SnippetCreateRequestResponse
+
# Builds
Types:
@@ -28,12 +52,14 @@ Types:
- BuildObject
- BuildTarget
- BuildListResponse
+- BuildCompareResponse
Methods:
- client.builds.create({ ...params }) -> BuildObject
- client.builds.retrieve(buildID) -> BuildObject
- client.builds.list({ ...params }) -> BuildListResponse
+- client.builds.compare({ ...params }) -> BuildCompareResponse
# BuildTargetOutputs
@@ -44,3 +70,15 @@ Types:
Methods:
- client.buildTargetOutputs.retrieve({ ...params }) -> BuildTargetOutputRetrieveResponse
+
+# Orgs
+
+Types:
+
+- OrgRetrieveResponse
+- OrgListResponse
+
+Methods:
+
+- client.orgs.retrieve(orgName) -> OrgRetrieveResponse
+- client.orgs.list() -> OrgListResponse
diff --git a/package.json b/package.json
index 82ab06a2..07e5c111 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
{
"name": "stainless-v0",
- "version": "0.1.0-alpha.1",
+ "version": "0.1.0-alpha.2",
"description": "The official TypeScript library for the Stainless V0 API",
"author": "Stainless V0 <>",
"types": "dist/index.d.ts",
@@ -17,7 +17,7 @@
"test": "./scripts/test",
"build": "./scripts/build",
"prepublishOnly": "echo 'to publish, run yarn build && (cd dist; yarn publish)' && exit 1",
- "format": "prettier --write --cache --cache-strategy metadata . !dist",
+ "format": "./scripts/format",
"prepare": "if ./scripts/utils/check-is-in-git-install.sh; then ./scripts/build && ./scripts/utils/git-swap.sh; fi",
"tsn": "ts-node -r tsconfig-paths/register",
"lint": "./scripts/lint",
@@ -30,9 +30,9 @@
"@swc/jest": "^0.2.29",
"@types/jest": "^29.4.0",
"@types/node": "^20.17.6",
- "typescript-eslint": "^8.24.0",
- "@typescript-eslint/eslint-plugin": "^8.24.0",
- "@typescript-eslint/parser": "^8.24.0",
+ "typescript-eslint": "8.31.1",
+ "@typescript-eslint/eslint-plugin": "8.31.1",
+ "@typescript-eslint/parser": "8.31.1",
"eslint": "^9.20.1",
"eslint-plugin-prettier": "^5.2.3",
"eslint-plugin-unused-imports": "^4.1.4",
@@ -42,17 +42,13 @@
"publint": "^0.2.12",
"ts-jest": "^29.1.0",
"ts-node": "^10.5.0",
- "tsc-multi": "https://github.com/stainless-api/tsc-multi/releases/download/v1.1.3/tsc-multi.tgz",
+ "tsc-multi": "https://github.com/stainless-api/tsc-multi/releases/download/v1.1.4/tsc-multi-1.1.4.tgz",
"tsconfig-paths": "^4.0.0",
- "typescript": "^4.8.2"
+ "typescript": "5.8.3"
},
"resolutions": {
"synckit": "0.8.8"
},
- "browser": {
- "./internal/shims/getBuiltinModule.mjs": "./internal/shims/nullGetBuiltinModule.mjs",
- "./internal/shims/getBuiltinModule.js": "./internal/shims/nullGetBuiltinModule.js"
- },
"imports": {
"stainless-v0": ".",
"stainless-v0/*": "./src/*"
diff --git a/release-please-config.json b/release-please-config.json
index 624ed99e..1ebd0bde 100644
--- a/release-please-config.json
+++ b/release-please-config.json
@@ -60,8 +60,5 @@
}
],
"release-type": "node",
- "extra-files": [
- "src/version.ts",
- "README.md"
- ]
+ "extra-files": ["src/version.ts", "README.md"]
}
diff --git a/scripts/build b/scripts/build
index 01803ef3..f4b330b6 100755
--- a/scripts/build
+++ b/scripts/build
@@ -19,9 +19,13 @@ for file in LICENSE CHANGELOG.md; do
if [ -e "${file}" ]; then cp "${file}" dist; fi
done
if [ -e "bin/cli" ]; then
- mkdir dist/bin
+ mkdir -p dist/bin
cp -p "bin/cli" dist/bin/;
fi
+if [ -e "bin/migration-config.json" ]; then
+ mkdir -p dist/bin
+ cp -p "bin/migration-config.json" dist/bin/;
+fi
# this converts the export map paths for the dist directory
# and does a few other minor things
node scripts/utils/make-dist-package-json.cjs > dist/package.json
diff --git a/scripts/format b/scripts/format
index 903b1ef8..7a756401 100755
--- a/scripts/format
+++ b/scripts/format
@@ -6,3 +6,7 @@ cd "$(dirname "$0")/.."
echo "==> Running eslint --fix"
./node_modules/.bin/eslint --fix .
+
+echo "==> Running prettier --write"
+# format things eslint didn't
+./node_modules/.bin/prettier --write --cache --cache-strategy metadata . '!**/dist' '!**/*.ts' '!**/*.mts' '!**/*.cts' '!**/*.js' '!**/*.mjs' '!**/*.cjs'
diff --git a/src/client.ts b/src/client.ts
index 0f2b87c6..e2883ddc 100644
--- a/src/client.ts
+++ b/src/client.ts
@@ -12,6 +12,7 @@ import type { APIResponseProps } from './internal/parse';
import { getPlatformHeaders } from './internal/detect-platform';
import * as Shims from './internal/shims';
import * as Opts from './internal/request-options';
+import * as qs from './internal/qs';
import { VERSION } from './version';
import * as Errors from './core/error';
import * as Uploads from './core/uploads';
@@ -26,6 +27,8 @@ import {
BuildTargetOutputs,
} from './resources/build-target-outputs';
import {
+ BuildCompareParams,
+ BuildCompareResponse,
BuildCreateParams,
BuildListParams,
BuildListResponse,
@@ -33,10 +36,13 @@ import {
BuildTarget,
Builds,
} from './resources/builds';
+import { OrgListResponse, OrgRetrieveResponse, Orgs } from './resources/orgs';
import { readEnv } from './internal/utils/env';
import { formatRequestDetails, loggerFor } from './internal/utils/log';
import { isEmptyObj } from './internal/utils/values';
import {
+ ProjectListParams,
+ ProjectListResponse,
ProjectRetrieveResponse,
ProjectUpdateParams,
ProjectUpdateResponse,
@@ -177,6 +183,23 @@ export class StainlessV0 {
this.apiKey = apiKey;
}
+ /**
+ * Create a new client instance re-using the same options given to the current client with optional overriding.
+ */
+ withOptions(options: Partial): this {
+ return new (this.constructor as any as new (props: ClientOptions) => typeof this)({
+ ...this._options,
+ baseURL: this.baseURL,
+ maxRetries: this.maxRetries,
+ timeout: this.timeout,
+ logger: this.logger,
+ logLevel: this.logLevel,
+ fetchOptions: this.fetchOptions,
+ apiKey: this.apiKey,
+ ...options,
+ });
+ }
+
protected defaultQuery(): Record | undefined {
return this._options.defaultQuery;
}
@@ -201,24 +224,8 @@ export class StainlessV0 {
return buildHeaders([{ Authorization: `Bearer ${this.apiKey}` }]);
}
- /**
- * Basic re-implementation of `qs.stringify` for primitive types.
- */
protected stringifyQuery(query: Record): string {
- return Object.entries(query)
- .filter(([_, value]) => typeof value !== 'undefined')
- .map(([key, value]) => {
- if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
- return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
- }
- if (value === null) {
- return `${encodeURIComponent(key)}=`;
- }
- throw new Errors.StainlessV0Error(
- `Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`,
- );
- })
- .join('&');
+ return qs.stringify(query, { arrayFormat: 'comma' });
}
private getUserAgent(): string {
@@ -493,12 +500,12 @@ export class StainlessV0 {
fetchOptions.method = method.toUpperCase();
}
- return (
+ try {
// use undefined this binding; fetch errors if bound to something else in browser/cloudflare
- this.fetch.call(undefined, url, fetchOptions).finally(() => {
- clearTimeout(timeout);
- })
- );
+ return await this.fetch.call(undefined, url, fetchOptions);
+ } finally {
+ clearTimeout(timeout);
+ }
}
private shouldRetry(response: Response): boolean {
@@ -701,10 +708,12 @@ export class StainlessV0 {
projects: API.Projects = new API.Projects(this);
builds: API.Builds = new API.Builds(this);
buildTargetOutputs: API.BuildTargetOutputs = new API.BuildTargetOutputs(this);
+ orgs: API.Orgs = new API.Orgs(this);
}
StainlessV0.Projects = Projects;
StainlessV0.Builds = Builds;
StainlessV0.BuildTargetOutputs = BuildTargetOutputs;
+StainlessV0.Orgs = Orgs;
export declare namespace StainlessV0 {
export type RequestOptions = Opts.RequestOptions;
@@ -712,7 +721,9 @@ export declare namespace StainlessV0 {
Projects as Projects,
type ProjectRetrieveResponse as ProjectRetrieveResponse,
type ProjectUpdateResponse as ProjectUpdateResponse,
+ type ProjectListResponse as ProjectListResponse,
type ProjectUpdateParams as ProjectUpdateParams,
+ type ProjectListParams as ProjectListParams,
};
export {
@@ -720,8 +731,10 @@ export declare namespace StainlessV0 {
type BuildObject as BuildObject,
type BuildTarget as BuildTarget,
type BuildListResponse as BuildListResponse,
+ type BuildCompareResponse as BuildCompareResponse,
type BuildCreateParams as BuildCreateParams,
type BuildListParams as BuildListParams,
+ type BuildCompareParams as BuildCompareParams,
};
export {
@@ -729,4 +742,10 @@ export declare namespace StainlessV0 {
type BuildTargetOutputRetrieveResponse as BuildTargetOutputRetrieveResponse,
type BuildTargetOutputRetrieveParams as BuildTargetOutputRetrieveParams,
};
+
+ export {
+ Orgs as Orgs,
+ type OrgRetrieveResponse as OrgRetrieveResponse,
+ type OrgListResponse as OrgListResponse,
+ };
}
diff --git a/src/internal/headers.ts b/src/internal/headers.ts
index a110a120..5cc03ce3 100644
--- a/src/internal/headers.ts
+++ b/src/internal/headers.ts
@@ -3,7 +3,7 @@
type HeaderValue = string | undefined | null;
export type HeadersLike =
| Headers
- | readonly [string, HeaderValue][]
+ | readonly HeaderValue[][]
| Record
| undefined
| null
@@ -40,7 +40,7 @@ function* iterateHeaders(headers: HeadersLike): IterableIterator;
+ let iter: Iterable;
if (headers instanceof Headers) {
iter = headers.entries();
} else if (isArray(headers)) {
@@ -51,6 +51,7 @@ function* iterateHeaders(headers: HeadersLike): IterableIterator {
const targetHeaders = new Headers();
const nullHeaders = new Set();
- const seenHeaders = new Set();
for (const headers of newHeaders) {
+ const seenHeaders = new Set();
for (const [name, value] of iterateHeaders(headers)) {
const lowerName = name.toLowerCase();
if (!seenHeaders.has(lowerName)) {
diff --git a/src/internal/qs/LICENSE.md b/src/internal/qs/LICENSE.md
new file mode 100644
index 00000000..3fda1573
--- /dev/null
+++ b/src/internal/qs/LICENSE.md
@@ -0,0 +1,13 @@
+BSD 3-Clause License
+
+Copyright (c) 2014, Nathan LaFreniere and other [contributors](https://github.com/puruvj/neoqs/graphs/contributors) All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/src/internal/qs/README.md b/src/internal/qs/README.md
new file mode 100644
index 00000000..67ae04ec
--- /dev/null
+++ b/src/internal/qs/README.md
@@ -0,0 +1,3 @@
+# qs
+
+This is a vendored version of [neoqs](https://github.com/PuruVJ/neoqs) which is a TypeScript rewrite of [qs](https://github.com/ljharb/qs), a query string library.
diff --git a/src/internal/qs/formats.ts b/src/internal/qs/formats.ts
new file mode 100644
index 00000000..1cf9e2cd
--- /dev/null
+++ b/src/internal/qs/formats.ts
@@ -0,0 +1,9 @@
+import type { Format } from './types';
+
+export const default_format: Format = 'RFC3986';
+export const formatters: Record string> = {
+ RFC1738: (v: PropertyKey) => String(v).replace(/%20/g, '+'),
+ RFC3986: (v: PropertyKey) => String(v),
+};
+export const RFC1738 = 'RFC1738';
+export const RFC3986 = 'RFC3986';
diff --git a/src/internal/qs/index.ts b/src/internal/qs/index.ts
new file mode 100644
index 00000000..c3a3620d
--- /dev/null
+++ b/src/internal/qs/index.ts
@@ -0,0 +1,13 @@
+import { default_format, formatters, RFC1738, RFC3986 } from './formats';
+
+const formats = {
+ formatters,
+ RFC1738,
+ RFC3986,
+ default: default_format,
+};
+
+export { stringify } from './stringify';
+export { formats };
+
+export type { DefaultDecoder, DefaultEncoder, Format, ParseOptions, StringifyOptions } from './types';
diff --git a/src/internal/qs/stringify.ts b/src/internal/qs/stringify.ts
new file mode 100644
index 00000000..67497561
--- /dev/null
+++ b/src/internal/qs/stringify.ts
@@ -0,0 +1,388 @@
+import { encode, is_buffer, maybe_map } from './utils';
+import { default_format, formatters } from './formats';
+import type { NonNullableProperties, StringifyOptions } from './types';
+
+const has = Object.prototype.hasOwnProperty;
+
+const array_prefix_generators = {
+ brackets(prefix: PropertyKey) {
+ return String(prefix) + '[]';
+ },
+ comma: 'comma',
+ indices(prefix: PropertyKey, key: string) {
+ return String(prefix) + '[' + key + ']';
+ },
+ repeat(prefix: PropertyKey) {
+ return String(prefix);
+ },
+};
+
+const is_array = Array.isArray;
+const push = Array.prototype.push;
+const push_to_array = function (arr: any[], value_or_array: any) {
+ push.apply(arr, is_array(value_or_array) ? value_or_array : [value_or_array]);
+};
+
+const to_ISO = Date.prototype.toISOString;
+
+const defaults = {
+ addQueryPrefix: false,
+ allowDots: false,
+ allowEmptyArrays: false,
+ arrayFormat: 'indices',
+ charset: 'utf-8',
+ charsetSentinel: false,
+ delimiter: '&',
+ encode: true,
+ encodeDotInKeys: false,
+ encoder: encode,
+ encodeValuesOnly: false,
+ format: default_format,
+ formatter: formatters[default_format],
+ /** @deprecated */
+ indices: false,
+ serializeDate(date) {
+ return to_ISO.call(date);
+ },
+ skipNulls: false,
+ strictNullHandling: false,
+} as NonNullableProperties;
+
+function is_non_nullish_primitive(v: unknown): v is string | number | boolean | symbol | bigint {
+ return (
+ typeof v === 'string' ||
+ typeof v === 'number' ||
+ typeof v === 'boolean' ||
+ typeof v === 'symbol' ||
+ typeof v === 'bigint'
+ );
+}
+
+const sentinel = {};
+
+function inner_stringify(
+ object: any,
+ prefix: PropertyKey,
+ generateArrayPrefix: StringifyOptions['arrayFormat'] | ((prefix: string, key: string) => string),
+ commaRoundTrip: boolean,
+ allowEmptyArrays: boolean,
+ strictNullHandling: boolean,
+ skipNulls: boolean,
+ encodeDotInKeys: boolean,
+ encoder: StringifyOptions['encoder'],
+ filter: StringifyOptions['filter'],
+ sort: StringifyOptions['sort'],
+ allowDots: StringifyOptions['allowDots'],
+ serializeDate: StringifyOptions['serializeDate'],
+ format: StringifyOptions['format'],
+ formatter: StringifyOptions['formatter'],
+ encodeValuesOnly: boolean,
+ charset: StringifyOptions['charset'],
+ sideChannel: WeakMap,
+) {
+ let obj = object;
+
+ let tmp_sc = sideChannel;
+ let step = 0;
+ let find_flag = false;
+ while ((tmp_sc = tmp_sc.get(sentinel)) !== void undefined && !find_flag) {
+ // Where object last appeared in the ref tree
+ const pos = tmp_sc.get(object);
+ step += 1;
+ if (typeof pos !== 'undefined') {
+ if (pos === step) {
+ throw new RangeError('Cyclic object value');
+ } else {
+ find_flag = true; // Break while
+ }
+ }
+ if (typeof tmp_sc.get(sentinel) === 'undefined') {
+ step = 0;
+ }
+ }
+
+ if (typeof filter === 'function') {
+ obj = filter(prefix, obj);
+ } else if (obj instanceof Date) {
+ obj = serializeDate?.(obj);
+ } else if (generateArrayPrefix === 'comma' && is_array(obj)) {
+ obj = maybe_map(obj, function (value) {
+ if (value instanceof Date) {
+ return serializeDate?.(value);
+ }
+ return value;
+ });
+ }
+
+ if (obj === null) {
+ if (strictNullHandling) {
+ return encoder && !encodeValuesOnly ?
+ // @ts-expect-error
+ encoder(prefix, defaults.encoder, charset, 'key', format)
+ : prefix;
+ }
+
+ obj = '';
+ }
+
+ if (is_non_nullish_primitive(obj) || is_buffer(obj)) {
+ if (encoder) {
+ const key_value =
+ encodeValuesOnly ? prefix
+ // @ts-expect-error
+ : encoder(prefix, defaults.encoder, charset, 'key', format);
+ return [
+ formatter?.(key_value) +
+ '=' +
+ // @ts-expect-error
+ formatter?.(encoder(obj, defaults.encoder, charset, 'value', format)),
+ ];
+ }
+ return [formatter?.(prefix) + '=' + formatter?.(String(obj))];
+ }
+
+ const values: string[] = [];
+
+ if (typeof obj === 'undefined') {
+ return values;
+ }
+
+ let obj_keys;
+ if (generateArrayPrefix === 'comma' && is_array(obj)) {
+ // we need to join elements in
+ if (encodeValuesOnly && encoder) {
+ // @ts-expect-error values only
+ obj = maybe_map(obj, encoder);
+ }
+ obj_keys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }];
+ } else if (is_array(filter)) {
+ obj_keys = filter;
+ } else {
+ const keys = Object.keys(obj);
+ obj_keys = sort ? keys.sort(sort) : keys;
+ }
+
+ const encoded_prefix = encodeDotInKeys ? String(prefix).replace(/\./g, '%2E') : String(prefix);
+
+ const adjusted_prefix =
+ commaRoundTrip && is_array(obj) && obj.length === 1 ? encoded_prefix + '[]' : encoded_prefix;
+
+ if (allowEmptyArrays && is_array(obj) && obj.length === 0) {
+ return adjusted_prefix + '[]';
+ }
+
+ for (let j = 0; j < obj_keys.length; ++j) {
+ const key = obj_keys[j];
+ const value =
+ // @ts-ignore
+ typeof key === 'object' && typeof key.value !== 'undefined' ? key.value : obj[key as any];
+
+ if (skipNulls && value === null) {
+ continue;
+ }
+
+ // @ts-ignore
+ const encoded_key = allowDots && encodeDotInKeys ? (key as any).replace(/\./g, '%2E') : key;
+ const key_prefix =
+ is_array(obj) ?
+ typeof generateArrayPrefix === 'function' ?
+ generateArrayPrefix(adjusted_prefix, encoded_key)
+ : adjusted_prefix
+ : adjusted_prefix + (allowDots ? '.' + encoded_key : '[' + encoded_key + ']');
+
+ sideChannel.set(object, step);
+ const valueSideChannel = new WeakMap();
+ valueSideChannel.set(sentinel, sideChannel);
+ push_to_array(
+ values,
+ inner_stringify(
+ value,
+ key_prefix,
+ generateArrayPrefix,
+ commaRoundTrip,
+ allowEmptyArrays,
+ strictNullHandling,
+ skipNulls,
+ encodeDotInKeys,
+ // @ts-ignore
+ generateArrayPrefix === 'comma' && encodeValuesOnly && is_array(obj) ? null : encoder,
+ filter,
+ sort,
+ allowDots,
+ serializeDate,
+ format,
+ formatter,
+ encodeValuesOnly,
+ charset,
+ valueSideChannel,
+ ),
+ );
+ }
+
+ return values;
+}
+
+function normalize_stringify_options(
+ opts: StringifyOptions = defaults,
+): NonNullableProperties> & { indices?: boolean } {
+ if (typeof opts.allowEmptyArrays !== 'undefined' && typeof opts.allowEmptyArrays !== 'boolean') {
+ throw new TypeError('`allowEmptyArrays` option can only be `true` or `false`, when provided');
+ }
+
+ if (typeof opts.encodeDotInKeys !== 'undefined' && typeof opts.encodeDotInKeys !== 'boolean') {
+ throw new TypeError('`encodeDotInKeys` option can only be `true` or `false`, when provided');
+ }
+
+ if (opts.encoder !== null && typeof opts.encoder !== 'undefined' && typeof opts.encoder !== 'function') {
+ throw new TypeError('Encoder has to be a function.');
+ }
+
+ const charset = opts.charset || defaults.charset;
+ if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {
+ throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');
+ }
+
+ let format = default_format;
+ if (typeof opts.format !== 'undefined') {
+ if (!has.call(formatters, opts.format)) {
+ throw new TypeError('Unknown format option provided.');
+ }
+ format = opts.format;
+ }
+ const formatter = formatters[format];
+
+ let filter = defaults.filter;
+ if (typeof opts.filter === 'function' || is_array(opts.filter)) {
+ filter = opts.filter;
+ }
+
+ let arrayFormat: StringifyOptions['arrayFormat'];
+ if (opts.arrayFormat && opts.arrayFormat in array_prefix_generators) {
+ arrayFormat = opts.arrayFormat;
+ } else if ('indices' in opts) {
+ arrayFormat = opts.indices ? 'indices' : 'repeat';
+ } else {
+ arrayFormat = defaults.arrayFormat;
+ }
+
+ if ('commaRoundTrip' in opts && typeof opts.commaRoundTrip !== 'boolean') {
+ throw new TypeError('`commaRoundTrip` must be a boolean, or absent');
+ }
+
+ const allowDots =
+ typeof opts.allowDots === 'undefined' ?
+ !!opts.encodeDotInKeys === true ?
+ true
+ : defaults.allowDots
+ : !!opts.allowDots;
+
+ return {
+ addQueryPrefix: typeof opts.addQueryPrefix === 'boolean' ? opts.addQueryPrefix : defaults.addQueryPrefix,
+ // @ts-ignore
+ allowDots: allowDots,
+ allowEmptyArrays:
+ typeof opts.allowEmptyArrays === 'boolean' ? !!opts.allowEmptyArrays : defaults.allowEmptyArrays,
+ arrayFormat: arrayFormat,
+ charset: charset,
+ charsetSentinel:
+ typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
+ commaRoundTrip: !!opts.commaRoundTrip,
+ delimiter: typeof opts.delimiter === 'undefined' ? defaults.delimiter : opts.delimiter,
+ encode: typeof opts.encode === 'boolean' ? opts.encode : defaults.encode,
+ encodeDotInKeys:
+ typeof opts.encodeDotInKeys === 'boolean' ? opts.encodeDotInKeys : defaults.encodeDotInKeys,
+ encoder: typeof opts.encoder === 'function' ? opts.encoder : defaults.encoder,
+ encodeValuesOnly:
+ typeof opts.encodeValuesOnly === 'boolean' ? opts.encodeValuesOnly : defaults.encodeValuesOnly,
+ filter: filter,
+ format: format,
+ formatter: formatter,
+ serializeDate: typeof opts.serializeDate === 'function' ? opts.serializeDate : defaults.serializeDate,
+ skipNulls: typeof opts.skipNulls === 'boolean' ? opts.skipNulls : defaults.skipNulls,
+ // @ts-ignore
+ sort: typeof opts.sort === 'function' ? opts.sort : null,
+ strictNullHandling:
+ typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling,
+ };
+}
+
+export function stringify(object: any, opts: StringifyOptions = {}) {
+ let obj = object;
+ const options = normalize_stringify_options(opts);
+
+ let obj_keys: PropertyKey[] | undefined;
+ let filter;
+
+ if (typeof options.filter === 'function') {
+ filter = options.filter;
+ obj = filter('', obj);
+ } else if (is_array(options.filter)) {
+ filter = options.filter;
+ obj_keys = filter;
+ }
+
+ const keys: string[] = [];
+
+ if (typeof obj !== 'object' || obj === null) {
+ return '';
+ }
+
+ const generateArrayPrefix = array_prefix_generators[options.arrayFormat];
+ const commaRoundTrip = generateArrayPrefix === 'comma' && options.commaRoundTrip;
+
+ if (!obj_keys) {
+ obj_keys = Object.keys(obj);
+ }
+
+ if (options.sort) {
+ obj_keys.sort(options.sort);
+ }
+
+ const sideChannel = new WeakMap();
+ for (let i = 0; i < obj_keys.length; ++i) {
+ const key = obj_keys[i]!;
+
+ if (options.skipNulls && obj[key] === null) {
+ continue;
+ }
+ push_to_array(
+ keys,
+ inner_stringify(
+ obj[key],
+ key,
+ // @ts-expect-error
+ generateArrayPrefix,
+ commaRoundTrip,
+ options.allowEmptyArrays,
+ options.strictNullHandling,
+ options.skipNulls,
+ options.encodeDotInKeys,
+ options.encode ? options.encoder : null,
+ options.filter,
+ options.sort,
+ options.allowDots,
+ options.serializeDate,
+ options.format,
+ options.formatter,
+ options.encodeValuesOnly,
+ options.charset,
+ sideChannel,
+ ),
+ );
+ }
+
+ const joined = keys.join(options.delimiter);
+ let prefix = options.addQueryPrefix === true ? '?' : '';
+
+ if (options.charsetSentinel) {
+ if (options.charset === 'iso-8859-1') {
+ // encodeURIComponent('✓'), the "numeric entity" representation of a checkmark
+ prefix += 'utf8=%26%2310003%3B&';
+ } else {
+ // encodeURIComponent('✓')
+ prefix += 'utf8=%E2%9C%93&';
+ }
+ }
+
+ return joined.length > 0 ? prefix + joined : '';
+}
diff --git a/src/internal/qs/types.ts b/src/internal/qs/types.ts
new file mode 100644
index 00000000..7c28dbb4
--- /dev/null
+++ b/src/internal/qs/types.ts
@@ -0,0 +1,71 @@
+export type Format = 'RFC1738' | 'RFC3986';
+
+export type DefaultEncoder = (str: any, defaultEncoder?: any, charset?: string) => string;
+export type DefaultDecoder = (str: string, decoder?: any, charset?: string) => string;
+
+export type BooleanOptional = boolean | undefined;
+
+export type StringifyBaseOptions = {
+ delimiter?: string;
+ allowDots?: boolean;
+ encodeDotInKeys?: boolean;
+ strictNullHandling?: boolean;
+ skipNulls?: boolean;
+ encode?: boolean;
+ encoder?: (
+ str: any,
+ defaultEncoder: DefaultEncoder,
+ charset: string,
+ type: 'key' | 'value',
+ format?: Format,
+ ) => string;
+ filter?: Array | ((prefix: PropertyKey, value: any) => any);
+ arrayFormat?: 'indices' | 'brackets' | 'repeat' | 'comma';
+ indices?: boolean;
+ sort?: ((a: PropertyKey, b: PropertyKey) => number) | null;
+ serializeDate?: (d: Date) => string;
+ format?: 'RFC1738' | 'RFC3986';
+ formatter?: (str: PropertyKey) => string;
+ encodeValuesOnly?: boolean;
+ addQueryPrefix?: boolean;
+ charset?: 'utf-8' | 'iso-8859-1';
+ charsetSentinel?: boolean;
+ allowEmptyArrays?: boolean;
+ commaRoundTrip?: boolean;
+};
+
+export type StringifyOptions = StringifyBaseOptions;
+
+export type ParseBaseOptions = {
+ comma?: boolean;
+ delimiter?: string | RegExp;
+ depth?: number | false;
+ decoder?: (str: string, defaultDecoder: DefaultDecoder, charset: string, type: 'key' | 'value') => any;
+ arrayLimit?: number;
+ parseArrays?: boolean;
+ plainObjects?: boolean;
+ allowPrototypes?: boolean;
+ allowSparse?: boolean;
+ parameterLimit?: number;
+ strictDepth?: boolean;
+ strictNullHandling?: boolean;
+ ignoreQueryPrefix?: boolean;
+ charset?: 'utf-8' | 'iso-8859-1';
+ charsetSentinel?: boolean;
+ interpretNumericEntities?: boolean;
+ allowEmptyArrays?: boolean;
+ duplicates?: 'combine' | 'first' | 'last';
+ allowDots?: boolean;
+ decodeDotInKeys?: boolean;
+};
+
+export type ParseOptions = ParseBaseOptions;
+
+export type ParsedQs = {
+ [key: string]: undefined | string | string[] | ParsedQs | ParsedQs[];
+};
+
+// Type to remove null or undefined union from each property
+export type NonNullableProperties = {
+ [K in keyof T]-?: Exclude;
+};
diff --git a/src/internal/qs/utils.ts b/src/internal/qs/utils.ts
new file mode 100644
index 00000000..113b18fb
--- /dev/null
+++ b/src/internal/qs/utils.ts
@@ -0,0 +1,265 @@
+import { RFC1738 } from './formats';
+import type { DefaultEncoder, Format } from './types';
+
+const has = Object.prototype.hasOwnProperty;
+const is_array = Array.isArray;
+
+const hex_table = (() => {
+ const array = [];
+ for (let i = 0; i < 256; ++i) {
+ array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
+ }
+
+ return array;
+})();
+
+function compact_queue>(queue: Array<{ obj: T; prop: string }>) {
+ while (queue.length > 1) {
+ const item = queue.pop();
+ if (!item) continue;
+
+ const obj = item.obj[item.prop];
+
+ if (is_array(obj)) {
+ const compacted: unknown[] = [];
+
+ for (let j = 0; j < obj.length; ++j) {
+ if (typeof obj[j] !== 'undefined') {
+ compacted.push(obj[j]);
+ }
+ }
+
+ // @ts-ignore
+ item.obj[item.prop] = compacted;
+ }
+ }
+}
+
+function array_to_object(source: any[], options: { plainObjects: boolean }) {
+ const obj = options && options.plainObjects ? Object.create(null) : {};
+ for (let i = 0; i < source.length; ++i) {
+ if (typeof source[i] !== 'undefined') {
+ obj[i] = source[i];
+ }
+ }
+
+ return obj;
+}
+
+export function merge(
+ target: any,
+ source: any,
+ options: { plainObjects?: boolean; allowPrototypes?: boolean } = {},
+) {
+ if (!source) {
+ return target;
+ }
+
+ if (typeof source !== 'object') {
+ if (is_array(target)) {
+ target.push(source);
+ } else if (target && typeof target === 'object') {
+ if (
+ (options && (options.plainObjects || options.allowPrototypes)) ||
+ !has.call(Object.prototype, source)
+ ) {
+ target[source] = true;
+ }
+ } else {
+ return [target, source];
+ }
+
+ return target;
+ }
+
+ if (!target || typeof target !== 'object') {
+ return [target].concat(source);
+ }
+
+ let mergeTarget = target;
+ if (is_array(target) && !is_array(source)) {
+ // @ts-ignore
+ mergeTarget = array_to_object(target, options);
+ }
+
+ if (is_array(target) && is_array(source)) {
+ source.forEach(function (item, i) {
+ if (has.call(target, i)) {
+ const targetItem = target[i];
+ if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
+ target[i] = merge(targetItem, item, options);
+ } else {
+ target.push(item);
+ }
+ } else {
+ target[i] = item;
+ }
+ });
+ return target;
+ }
+
+ return Object.keys(source).reduce(function (acc, key) {
+ const value = source[key];
+
+ if (has.call(acc, key)) {
+ acc[key] = merge(acc[key], value, options);
+ } else {
+ acc[key] = value;
+ }
+ return acc;
+ }, mergeTarget);
+}
+
+export function assign_single_source(target: any, source: any) {
+ return Object.keys(source).reduce(function (acc, key) {
+ acc[key] = source[key];
+ return acc;
+ }, target);
+}
+
+export function decode(str: string, _: any, charset: string) {
+ const strWithoutPlus = str.replace(/\+/g, ' ');
+ if (charset === 'iso-8859-1') {
+ // unescape never throws, no try...catch needed:
+ return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
+ }
+ // utf-8
+ try {
+ return decodeURIComponent(strWithoutPlus);
+ } catch (e) {
+ return strWithoutPlus;
+ }
+}
+
+const limit = 1024;
+
+export const encode: (
+ str: any,
+ defaultEncoder: DefaultEncoder,
+ charset: string,
+ type: 'key' | 'value',
+ format: Format,
+) => string = (str, _defaultEncoder, charset, _kind, format: Format) => {
+ // This code was originally written by Brian White for the io.js core querystring library.
+ // It has been adapted here for stricter adherence to RFC 3986
+ if (str.length === 0) {
+ return str;
+ }
+
+ let string = str;
+ if (typeof str === 'symbol') {
+ string = Symbol.prototype.toString.call(str);
+ } else if (typeof str !== 'string') {
+ string = String(str);
+ }
+
+ if (charset === 'iso-8859-1') {
+ return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
+ return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
+ });
+ }
+
+ let out = '';
+ for (let j = 0; j < string.length; j += limit) {
+ const segment = string.length >= limit ? string.slice(j, j + limit) : string;
+ const arr = [];
+
+ for (let i = 0; i < segment.length; ++i) {
+ let c = segment.charCodeAt(i);
+ if (
+ c === 0x2d || // -
+ c === 0x2e || // .
+ c === 0x5f || // _
+ c === 0x7e || // ~
+ (c >= 0x30 && c <= 0x39) || // 0-9
+ (c >= 0x41 && c <= 0x5a) || // a-z
+ (c >= 0x61 && c <= 0x7a) || // A-Z
+ (format === RFC1738 && (c === 0x28 || c === 0x29)) // ( )
+ ) {
+ arr[arr.length] = segment.charAt(i);
+ continue;
+ }
+
+ if (c < 0x80) {
+ arr[arr.length] = hex_table[c];
+ continue;
+ }
+
+ if (c < 0x800) {
+ arr[arr.length] = hex_table[0xc0 | (c >> 6)]! + hex_table[0x80 | (c & 0x3f)];
+ continue;
+ }
+
+ if (c < 0xd800 || c >= 0xe000) {
+ arr[arr.length] =
+ hex_table[0xe0 | (c >> 12)]! + hex_table[0x80 | ((c >> 6) & 0x3f)] + hex_table[0x80 | (c & 0x3f)];
+ continue;
+ }
+
+ i += 1;
+ c = 0x10000 + (((c & 0x3ff) << 10) | (segment.charCodeAt(i) & 0x3ff));
+
+ arr[arr.length] =
+ hex_table[0xf0 | (c >> 18)]! +
+ hex_table[0x80 | ((c >> 12) & 0x3f)] +
+ hex_table[0x80 | ((c >> 6) & 0x3f)] +
+ hex_table[0x80 | (c & 0x3f)];
+ }
+
+ out += arr.join('');
+ }
+
+ return out;
+};
+
+export function compact(value: any) {
+ const queue = [{ obj: { o: value }, prop: 'o' }];
+ const refs = [];
+
+ for (let i = 0; i < queue.length; ++i) {
+ const item = queue[i];
+ // @ts-ignore
+ const obj = item.obj[item.prop];
+
+ const keys = Object.keys(obj);
+ for (let j = 0; j < keys.length; ++j) {
+ const key = keys[j]!;
+ const val = obj[key];
+ if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
+ queue.push({ obj: obj, prop: key });
+ refs.push(val);
+ }
+ }
+ }
+
+ compact_queue(queue);
+
+ return value;
+}
+
+export function is_regexp(obj: any) {
+ return Object.prototype.toString.call(obj) === '[object RegExp]';
+}
+
+export function is_buffer(obj: any) {
+ if (!obj || typeof obj !== 'object') {
+ return false;
+ }
+
+ return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+}
+
+export function combine(a: any, b: any) {
+ return [].concat(a, b);
+}
+
+export function maybe_map(val: T[], fn: (v: T) => T) {
+ if (is_array(val)) {
+ const mapped = [];
+ for (let i = 0; i < val.length; i += 1) {
+ mapped.push(fn(val[i]!));
+ }
+ return mapped;
+ }
+ return fn(val);
+}
diff --git a/src/internal/shims/crypto.ts b/src/internal/shims/crypto.ts
deleted file mode 100644
index 905f81c6..00000000
--- a/src/internal/shims/crypto.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-import { getBuiltinModule } from './getBuiltinModule';
-
-type Crypto = {
- /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Crypto/getRandomValues) */
- getRandomValues(array: T): T;
- /**
- * Available only in secure contexts.
- *
- * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Crypto/randomUUID)
- */
- randomUUID?: () => string;
-};
-export let getCrypto: () => Crypto | undefined = function lazyGetCrypto() {
- if (getCrypto !== lazyGetCrypto) return getCrypto();
- const crypto: Crypto = (globalThis as any).crypto || (getBuiltinModule?.('node:crypto') as any)?.webcrypto;
- getCrypto = () => crypto;
- return crypto;
-};
diff --git a/src/internal/shims/file.ts b/src/internal/shims/file.ts
deleted file mode 100644
index d5dc8209..00000000
--- a/src/internal/shims/file.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import { getBuiltinModule } from './getBuiltinModule';
-
-export let getFile = function lazyGetFile(): FileConstructor {
- if (getFile !== lazyGetFile) return getFile();
- // We can drop getBuiltinModule once we no longer support Node < 20.0.0
- const File = (globalThis as any).File ?? (getBuiltinModule?.('node:buffer') as any)?.File;
- if (!File) throw new Error('`File` is not defined as a global, which is required for file uploads.');
- getFile = () => File;
- return File;
-};
-
-type FileConstructor =
- typeof globalThis extends { File: infer fileConstructor } ? fileConstructor : typeof FallbackFile;
-export type File = InstanceType;
-
-// The infer is to make TS show it as a nice union type,
-// instead of literally `ConstructorParameters[0]`
-type FallbackBlobSource = ConstructorParameters[0] extends infer T ? T : never;
-/**
- * A [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File) provides information about files.
- */
-declare class FallbackFile extends Blob {
- constructor(sources: FallbackBlobSource, fileName: string, options?: any);
- /**
- * The name of the `File`.
- */
- readonly name: string;
- /**
- * The last modified date of the `File`.
- */
- readonly lastModified: number;
-}
diff --git a/src/internal/shims/getBuiltinModule.ts b/src/internal/shims/getBuiltinModule.ts
deleted file mode 100644
index 64daa2ce..00000000
--- a/src/internal/shims/getBuiltinModule.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-/**
- * Load a Node built-in module. ID may or may not be prefixed by `node:` and
- * will be normalized. If we used static imports then our bundle size would be bloated by
- * injected polyfills, and if we used dynamic require then in addition to bundlers logging warnings,
- * our code would not work when bundled to ESM and run in Node 18.
- * @param {string} id ID of the built-in to be loaded.
- * @returns {object|undefined} exports of the built-in. Undefined if the built-in
- * does not exist.
- */
-export let getBuiltinModule: null | ((id: string) => object | undefined) = function getBuiltinModuleLazy(
- id: string,
-): object | undefined {
- try {
- if (getBuiltinModule !== getBuiltinModuleLazy) return getBuiltinModule!(id);
- if ((process as any).getBuiltinModule) {
- getBuiltinModule = (process as any).getBuiltinModule;
- } else {
- /* Fallback implementation for Node 18 */
- function createFallbackGetBuiltinModule(BuiltinModule: any) {
- return function getBuiltinModule(id: string): object | undefined {
- id = BuiltinModule.normalizeRequirableId(String(id));
- if (!BuiltinModule.canBeRequiredByUsers(id)) {
- return;
- }
- const mod = BuiltinModule.map.get(id);
- mod.compileForPublicLoader();
- return mod.exports;
- };
- }
- const magicKey = Math.random() + '';
- let module: { BuiltinModule: any } | undefined;
- let ObjectPrototype: {} = Blob;
- for (let next; (next = Reflect.getPrototypeOf(ObjectPrototype)); ObjectPrototype = next);
- try {
- const kClone = Object.getOwnPropertySymbols(Blob.prototype).find(
- (e) => e.description?.includes('clone'),
- )!;
- Object.defineProperty(ObjectPrototype, magicKey, {
- get() {
- module = this;
- throw null;
- },
- configurable: true,
- });
- structuredClone(
- new (class extends Blob {
- [kClone]() {
- return {
- deserializeInfo: 'internal/bootstrap/realm:' + magicKey,
- };
- }
- })([]),
- );
- } catch {}
- delete (ObjectPrototype as any)[magicKey];
- if (module) {
- getBuiltinModule = createFallbackGetBuiltinModule(module.BuiltinModule);
- } else {
- getBuiltinModule = () => undefined;
- }
- }
- return getBuiltinModule!(id);
- } catch {
- return undefined;
- }
-};
diff --git a/src/internal/shims/nullGetBuiltinModule.ts b/src/internal/shims/nullGetBuiltinModule.ts
deleted file mode 100644
index 8bd2280d..00000000
--- a/src/internal/shims/nullGetBuiltinModule.ts
+++ /dev/null
@@ -1 +0,0 @@
-export const getBuiltinModule = null;
diff --git a/src/internal/to-file.ts b/src/internal/to-file.ts
index e92ac694..245e8493 100644
--- a/src/internal/to-file.ts
+++ b/src/internal/to-file.ts
@@ -1,6 +1,6 @@
-import { type File, getFile } from './shims/file';
import { BlobPart, getName, makeFile, isAsyncIterable } from './uploads';
import type { FilePropertyBag } from './builtin-types';
+import { checkFileSupport } from './uploads';
type BlobLikePart = string | ArrayBuffer | ArrayBufferView | BlobLike | DataView;
@@ -85,12 +85,14 @@ export async function toFile(
name?: string | null | undefined,
options?: FilePropertyBag | undefined,
): Promise {
+ checkFileSupport();
+
// If it's a promise, resolve it.
value = await value;
// If we've been given a `File` we don't need to do anything
if (isFileLike(value)) {
- if (value instanceof getFile()) {
+ if (value instanceof File) {
return value;
}
return makeFile([await value.arrayBuffer()], value.name);
diff --git a/src/internal/uploads.ts b/src/internal/uploads.ts
index 60d6ddc1..ce0c2e8a 100644
--- a/src/internal/uploads.ts
+++ b/src/internal/uploads.ts
@@ -1,7 +1,6 @@
import { type RequestOptions } from './request-options';
import type { FilePropertyBag, Fetch } from './builtin-types';
import type { StainlessV0 } from '../client';
-import { type File, getFile } from './shims/file';
import { ReadableStreamFrom } from './shims';
export type BlobPart = string | ArrayBuffer | ArrayBufferView | Blob | DataView;
@@ -12,6 +11,20 @@ interface BunFile extends Blob {
readonly name?: string | undefined;
}
+export const checkFileSupport = () => {
+ if (typeof File === 'undefined') {
+ const { process } = globalThis as any;
+ const isOldNode =
+ typeof process?.versions?.node === 'string' && parseInt(process.versions.node.split('.')) < 20;
+ throw new Error(
+ '`File` is not defined as a global, which is required for file uploads.' +
+ (isOldNode ?
+ " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`."
+ : ''),
+ );
+ }
+};
+
/**
* Typically, this is a native "File" class.
*
@@ -32,7 +45,7 @@ export function makeFile(
fileName: string | undefined,
options?: FilePropertyBag,
): File {
- const File = getFile();
+ checkFileSupport();
return new File(fileBits as any, fileName ?? 'unknown_file', options);
}
@@ -125,8 +138,7 @@ export const createForm = async >(
// We check for Blob not File because Bun.File doesn't inherit from File,
// but they both inherit from Blob and have a `name` property at runtime.
-const isNamedBlob = (value: object) =>
- value instanceof getFile() || (value instanceof Blob && 'name' in value);
+const isNamedBlob = (value: object) => value instanceof Blob && 'name' in value;
const isUploadable = (value: unknown) =>
typeof value === 'object' &&
diff --git a/src/internal/utils/base64.ts b/src/internal/utils/base64.ts
index 09ee5d92..2a12fd42 100644
--- a/src/internal/utils/base64.ts
+++ b/src/internal/utils/base64.ts
@@ -1,18 +1,19 @@
// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
import { StainlessV0Error } from '../../core/error';
+import { encodeUTF8 } from './bytes';
export const toBase64 = (data: string | Uint8Array | null | undefined): string => {
if (!data) return '';
- if (typeof data === 'string') {
- data = new (globalThis as any).TextEncoder().encode(data);
- }
-
if (typeof (globalThis as any).Buffer !== 'undefined') {
return (globalThis as any).Buffer.from(data).toString('base64');
}
+ if (typeof data === 'string') {
+ data = encodeUTF8(data);
+ }
+
if (typeof btoa !== 'undefined') {
return btoa(String.fromCharCode.apply(null, data as any));
}
@@ -22,15 +23,17 @@ export const toBase64 = (data: string | Uint8Array | null | undefined): string =
export const fromBase64 = (str: string): Uint8Array => {
if (typeof (globalThis as any).Buffer !== 'undefined') {
- return new Uint8Array((globalThis as any).Buffer.from(str, 'base64'));
+ const buf = (globalThis as any).Buffer.from(str, 'base64');
+ return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
}
if (typeof atob !== 'undefined') {
- return new Uint8Array(
- atob(str)
- .split('')
- .map((c) => c.charCodeAt(0)),
- );
+ const bstr = atob(str);
+ const buf = new Uint8Array(bstr.length);
+ for (let i = 0; i < bstr.length; i++) {
+ buf[i] = bstr.charCodeAt(i);
+ }
+ return buf;
}
throw new StainlessV0Error('Cannot decode base64 string; Expected `Buffer` or `atob` to be defined');
diff --git a/src/internal/utils/bytes.ts b/src/internal/utils/bytes.ts
new file mode 100644
index 00000000..8da627ab
--- /dev/null
+++ b/src/internal/utils/bytes.ts
@@ -0,0 +1,32 @@
+export function concatBytes(buffers: Uint8Array[]): Uint8Array {
+ let length = 0;
+ for (const buffer of buffers) {
+ length += buffer.length;
+ }
+ const output = new Uint8Array(length);
+ let index = 0;
+ for (const buffer of buffers) {
+ output.set(buffer, index);
+ index += buffer.length;
+ }
+
+ return output;
+}
+
+let encodeUTF8_: (str: string) => Uint8Array;
+export function encodeUTF8(str: string) {
+ let encoder;
+ return (
+ encodeUTF8_ ??
+ ((encoder = new (globalThis as any).TextEncoder()), (encodeUTF8_ = encoder.encode.bind(encoder)))
+ )(str);
+}
+
+let decodeUTF8_: (bytes: Uint8Array) => string;
+export function decodeUTF8(bytes: Uint8Array) {
+ let decoder;
+ return (
+ decodeUTF8_ ??
+ ((decoder = new (globalThis as any).TextDecoder()), (decodeUTF8_ = decoder.decode.bind(decoder)))
+ )(bytes);
+}
diff --git a/src/internal/utils/uuid.ts b/src/internal/utils/uuid.ts
index 5a262c6d..b0e53aaf 100644
--- a/src/internal/utils/uuid.ts
+++ b/src/internal/utils/uuid.ts
@@ -1,12 +1,10 @@
// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-import { getCrypto } from '../shims/crypto';
-
/**
* https://stackoverflow.com/a/2117523
*/
export let uuid4 = function () {
- const crypto = getCrypto();
+ const { crypto } = globalThis as any;
if (crypto?.randomUUID) {
uuid4 = crypto.randomUUID.bind(crypto);
return crypto.randomUUID();
diff --git a/src/resources/build-target-outputs.ts b/src/resources/build-target-outputs.ts
index 684a9e9d..3f6f17d7 100644
--- a/src/resources/build-target-outputs.ts
+++ b/src/resources/build-target-outputs.ts
@@ -6,7 +6,7 @@ import { RequestOptions } from '../internal/request-options';
export class BuildTargetOutputs extends APIResource {
/**
- * TODO
+ * Download the output of a build target
*/
retrieve(
query: BuildTargetOutputRetrieveParams,
@@ -59,7 +59,18 @@ export interface BuildTargetOutputRetrieveParams {
/**
* SDK language target name
*/
- target: 'node' | 'typescript' | 'python' | 'go' | 'java' | 'kotlin' | 'ruby' | 'terraform' | 'cli';
+ target:
+ | 'node'
+ | 'typescript'
+ | 'python'
+ | 'go'
+ | 'java'
+ | 'kotlin'
+ | 'ruby'
+ | 'terraform'
+ | 'cli'
+ | 'php'
+ | 'csharp';
/**
* Type of output to download: source code
diff --git a/src/resources/builds.ts b/src/resources/builds.ts
index ceb7598b..bcda5169 100644
--- a/src/resources/builds.ts
+++ b/src/resources/builds.ts
@@ -8,25 +8,32 @@ import { path } from '../internal/utils/path';
export class Builds extends APIResource {
/**
- * TODO
+ * Create a new build
*/
create(body: BuildCreateParams, options?: RequestOptions): APIPromise {
return this._client.post('/v0/builds', { body, ...options });
}
/**
- * TODO
+ * Retrieve a build by ID
*/
retrieve(buildID: string, options?: RequestOptions): APIPromise {
return this._client.get(path`/v0/builds/${buildID}`, options);
}
/**
- * TODO
+ * List builds for a project
*/
list(query: BuildListParams, options?: RequestOptions): APIPromise {
return this._client.get('/v0/builds', { query, ...options });
}
+
+ /**
+ * Creates two builds whose outputs can be compared directly
+ */
+ compare(body: BuildCompareParams, options?: RequestOptions): APIPromise {
+ return this._client.post('/v0/builds/compare', { body, ...options });
+ }
}
export interface BuildObject {
@@ -36,6 +43,10 @@ export interface BuildObject {
object: 'build';
+ org: string;
+
+ project: string;
+
targets: BuildObject.Targets;
}
@@ -43,6 +54,8 @@ export namespace BuildObject {
export interface Targets {
cli?: BuildsAPI.BuildTarget;
+ csharp?: BuildsAPI.BuildTarget;
+
go?: BuildsAPI.BuildTarget;
java?: BuildsAPI.BuildTarget;
@@ -51,6 +64,8 @@ export namespace BuildObject {
node?: BuildsAPI.BuildTarget;
+ php?: BuildsAPI.BuildTarget;
+
python?: BuildsAPI.BuildTarget;
ruby?: BuildsAPI.BuildTarget;
@@ -239,6 +254,12 @@ export interface BuildListResponse {
next_cursor?: string;
}
+export interface BuildCompareResponse {
+ base: BuildObject;
+
+ head: BuildObject;
+}
+
export interface BuildCreateParams {
/**
* Project name
@@ -271,7 +292,19 @@ export interface BuildCreateParams {
* Optional list of SDK targets to build. If not specified, all configured targets
* will be built.
*/
- targets?: Array<'node' | 'typescript' | 'python' | 'go' | 'java' | 'kotlin' | 'ruby' | 'terraform' | 'cli'>;
+ targets?: Array<
+ | 'node'
+ | 'typescript'
+ | 'python'
+ | 'go'
+ | 'java'
+ | 'kotlin'
+ | 'ruby'
+ | 'terraform'
+ | 'cli'
+ | 'php'
+ | 'csharp'
+ >;
}
export namespace BuildCreateParams {
@@ -294,20 +327,126 @@ export interface BuildListParams {
*/
branch?: string;
- /**
- * Config commit SHA
- */
- config_commit?: string;
-
/**
* Pagination cursor from a previous response
*/
cursor?: string;
/**
- * Maximum number of builds to return, defaults to 10
+ * Maximum number of builds to return, defaults to 10 (maximum: 100)
*/
limit?: number;
+
+ /**
+ * A config commit SHA used for the build
+ */
+ revision?: string | Record;
+}
+
+export namespace BuildListParams {
+ export interface unnamed_schema_with_map_parent_1 {
+ /**
+ * File content hash
+ */
+ hash: string;
+ }
+}
+
+export interface BuildCompareParams {
+ /**
+ * Parameters for the base build
+ */
+ base: BuildCompareParams.Base;
+
+ /**
+ * Parameters for the head build
+ */
+ head: BuildCompareParams.Head;
+
+ /**
+ * Project name
+ */
+ project: string;
+
+ /**
+ * Optional list of SDK targets to build. If not specified, all configured targets
+ * will be built.
+ */
+ targets?: Array<
+ | 'node'
+ | 'typescript'
+ | 'python'
+ | 'go'
+ | 'java'
+ | 'kotlin'
+ | 'ruby'
+ | 'terraform'
+ | 'cli'
+ | 'php'
+ | 'csharp'
+ >;
+}
+
+export namespace BuildCompareParams {
+ /**
+ * Parameters for the base build
+ */
+ export interface Base {
+ /**
+ * Specifies what to build: a branch name, a commit SHA, or file contents
+ */
+ revision: string | Record;
+
+ /**
+ * Optional branch to use. If not specified, defaults to "main". When using a
+ * branch name as revision, this must match or be omitted.
+ */
+ branch?: string;
+
+ /**
+ * Optional commit message to use when creating a new commit.
+ */
+ commit_message?: string;
+ }
+
+ export namespace Base {
+ export interface unnamed_schema_with_map_parent_2 {
+ /**
+ * The file content
+ */
+ content: string;
+ }
+ }
+
+ /**
+ * Parameters for the head build
+ */
+ export interface Head {
+ /**
+ * Specifies what to build: a branch name, a commit SHA, or file contents
+ */
+ revision: string | Record;
+
+ /**
+ * Optional branch to use. If not specified, defaults to "main". When using a
+ * branch name as revision, this must match or be omitted.
+ */
+ branch?: string;
+
+ /**
+ * Optional commit message to use when creating a new commit.
+ */
+ commit_message?: string;
+ }
+
+ export namespace Head {
+ export interface unnamed_schema_with_map_parent_3 {
+ /**
+ * The file content
+ */
+ content: string;
+ }
+ }
}
export declare namespace Builds {
@@ -315,7 +454,9 @@ export declare namespace Builds {
type BuildObject as BuildObject,
type BuildTarget as BuildTarget,
type BuildListResponse as BuildListResponse,
+ type BuildCompareResponse as BuildCompareResponse,
type BuildCreateParams as BuildCreateParams,
type BuildListParams as BuildListParams,
+ type BuildCompareParams as BuildCompareParams,
};
}
diff --git a/src/resources/index.ts b/src/resources/index.ts
index e100dc2a..0bc35c6d 100644
--- a/src/resources/index.ts
+++ b/src/resources/index.ts
@@ -10,12 +10,17 @@ export {
type BuildObject,
type BuildTarget,
type BuildListResponse,
+ type BuildCompareResponse,
type BuildCreateParams,
type BuildListParams,
+ type BuildCompareParams,
} from './builds';
+export { Orgs, type OrgRetrieveResponse, type OrgListResponse } from './orgs';
export {
Projects,
type ProjectRetrieveResponse,
type ProjectUpdateResponse,
+ type ProjectListResponse,
type ProjectUpdateParams,
+ type ProjectListParams,
} from './projects/projects';
diff --git a/src/resources/orgs.ts b/src/resources/orgs.ts
new file mode 100644
index 00000000..26c73c8b
--- /dev/null
+++ b/src/resources/orgs.ts
@@ -0,0 +1,52 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { RequestOptions } from '../internal/request-options';
+import { path } from '../internal/utils/path';
+
+export class Orgs extends APIResource {
+ /**
+ * Retrieve an organization by name
+ */
+ retrieve(orgName: string, options?: RequestOptions): APIPromise {
+ return this._client.get(path`/v0/orgs/${orgName}`, options);
+ }
+
+ /**
+ * List organizations the user has access to
+ */
+ list(options?: RequestOptions): APIPromise {
+ return this._client.get('/v0/orgs', options);
+ }
+}
+
+export interface OrgRetrieveResponse {
+ display_name: string | null;
+
+ object: 'org';
+
+ slug: string;
+}
+
+export interface OrgListResponse {
+ data: Array;
+
+ has_more: boolean;
+
+ next_cursor?: string;
+}
+
+export namespace OrgListResponse {
+ export interface Data {
+ display_name: string | null;
+
+ object: 'org';
+
+ slug: string;
+ }
+}
+
+export declare namespace Orgs {
+ export { type OrgRetrieveResponse as OrgRetrieveResponse, type OrgListResponse as OrgListResponse };
+}
diff --git a/src/resources/projects/branches.ts b/src/resources/projects/branches.ts
index 75ca4e43..e6389b3c 100644
--- a/src/resources/projects/branches.ts
+++ b/src/resources/projects/branches.ts
@@ -8,14 +8,14 @@ import { path } from '../../internal/utils/path';
export class Branches extends APIResource {
/**
- * TODO
+ * Create a new branch for a project
*/
create(project: string, body: BranchCreateParams, options?: RequestOptions): APIPromise {
return this._client.post(path`/v0/projects/${project}/branches`, { body, ...options });
}
/**
- * TODO
+ * Retrieve a project branch
*/
retrieve(
branch: string,
@@ -60,9 +60,20 @@ export namespace ProjectBranch {
}
export interface BranchCreateParams {
+ /**
+ * Name of the new project branch.
+ */
branch: string;
+ /**
+ * Branch or commit SHA to branch from.
+ */
branch_from: string;
+
+ /**
+ * Whether to throw an error if the branch already exists. Defaults to false.
+ */
+ force?: boolean;
}
export interface BranchRetrieveParams {
diff --git a/src/resources/projects/configs.ts b/src/resources/projects/configs.ts
new file mode 100644
index 00000000..42e105f0
--- /dev/null
+++ b/src/resources/projects/configs.ts
@@ -0,0 +1,82 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Configs extends APIResource {
+ /**
+ * Retrieve configuration files for a project
+ */
+ retrieve(
+ project: string,
+ query: ConfigRetrieveParams | null | undefined = {},
+ options?: RequestOptions,
+ ): APIPromise {
+ return this._client.get(path`/v0/projects/${project}/configs`, { query, ...options });
+ }
+
+ /**
+ * Generate configuration suggestions based on an OpenAPI spec
+ */
+ guess(project: string, body: ConfigGuessParams, options?: RequestOptions): APIPromise {
+ return this._client.post(path`/v0/projects/${project}/configs/guess`, { body, ...options });
+ }
+}
+
+/**
+ * Config files contents
+ */
+export type ConfigRetrieveResponse = Record;
+
+export namespace ConfigRetrieveResponse {
+ export interface item {
+ /**
+ * The file content
+ */
+ content: string;
+ }
+}
+
+/**
+ * Config files contents
+ */
+export type ConfigGuessResponse = Record;
+
+export namespace ConfigGuessResponse {
+ export interface item {
+ /**
+ * The file content
+ */
+ content: string;
+ }
+}
+
+export interface ConfigRetrieveParams {
+ /**
+ * Branch name, defaults to "main"
+ */
+ branch?: string;
+}
+
+export interface ConfigGuessParams {
+ /**
+ * OpenAPI spec
+ */
+ spec: string;
+
+ /**
+ * Branch name
+ */
+ branch?: string;
+}
+
+export declare namespace Configs {
+ export {
+ type ConfigRetrieveResponse as ConfigRetrieveResponse,
+ type ConfigGuessResponse as ConfigGuessResponse,
+ type ConfigRetrieveParams as ConfigRetrieveParams,
+ type ConfigGuessParams as ConfigGuessParams,
+ };
+}
diff --git a/src/resources/projects/index.ts b/src/resources/projects/index.ts
index 86ab769d..942f8011 100644
--- a/src/resources/projects/index.ts
+++ b/src/resources/projects/index.ts
@@ -1,9 +1,19 @@
// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
export { Branches, type ProjectBranch, type BranchCreateParams, type BranchRetrieveParams } from './branches';
+export {
+ Configs,
+ type ConfigRetrieveResponse,
+ type ConfigGuessResponse,
+ type ConfigRetrieveParams,
+ type ConfigGuessParams,
+} from './configs';
export {
Projects,
type ProjectRetrieveResponse,
type ProjectUpdateResponse,
+ type ProjectListResponse,
type ProjectUpdateParams,
+ type ProjectListParams,
} from './projects';
+export { Snippets, type SnippetCreateRequestResponse, type SnippetCreateRequestParams } from './snippets';
diff --git a/src/resources/projects/projects.ts b/src/resources/projects/projects.ts
index a48d417f..1d69be9e 100644
--- a/src/resources/projects/projects.ts
+++ b/src/resources/projects/projects.ts
@@ -3,22 +3,34 @@
import { APIResource } from '../../core/resource';
import * as BranchesAPI from './branches';
import { BranchCreateParams, BranchRetrieveParams, Branches, ProjectBranch } from './branches';
+import * as ConfigsAPI from './configs';
+import {
+ ConfigGuessParams,
+ ConfigGuessResponse,
+ ConfigRetrieveParams,
+ ConfigRetrieveResponse,
+ Configs,
+} from './configs';
+import * as SnippetsAPI from './snippets';
+import { SnippetCreateRequestParams, SnippetCreateRequestResponse, Snippets } from './snippets';
import { APIPromise } from '../../core/api-promise';
import { RequestOptions } from '../../internal/request-options';
import { path } from '../../internal/utils/path';
export class Projects extends APIResource {
branches: BranchesAPI.Branches = new BranchesAPI.Branches(this._client);
+ configs: ConfigsAPI.Configs = new ConfigsAPI.Configs(this._client);
+ snippets: SnippetsAPI.Snippets = new SnippetsAPI.Snippets(this._client);
/**
- * TODO
+ * Retrieve a project by name
*/
retrieve(projectName: string, options?: RequestOptions): APIPromise {
return this._client.get(path`/v0/projects/${projectName}`, options);
}
/**
- * TODO
+ * Update a project's properties
*/
update(
projectName: string,
@@ -27,6 +39,13 @@ export class Projects extends APIResource {
): APIPromise {
return this._client.patch(path`/v0/projects/${projectName}`, { body, ...options });
}
+
+ /**
+ * List projects in an organization
+ */
+ list(query: ProjectListParams, options?: RequestOptions): APIPromise {
+ return this._client.get('/v0/projects', { query, ...options });
+ }
}
export interface ProjectRetrieveResponse {
@@ -53,17 +72,57 @@ export interface ProjectUpdateResponse {
slug: string;
}
+export interface ProjectListResponse {
+ data: Array;
+
+ has_more: boolean;
+
+ next_cursor?: string;
+}
+
+export namespace ProjectListResponse {
+ export interface Data {
+ config_repo: string;
+
+ display_name: string | null;
+
+ object: 'project';
+
+ org: string;
+
+ slug: string;
+ }
+}
+
export interface ProjectUpdateParams {
display_name?: string | null;
}
+export interface ProjectListParams {
+ org: string;
+
+ /**
+ * Pagination cursor from a previous response
+ */
+ cursor?: string;
+
+ /**
+ * Maximum number of projects to return, defaults to 10 (maximum: 100)
+ */
+ limit?: number;
+}
+
Projects.Branches = Branches;
+Projects.Configs = Configs;
+Projects.Snippets = Snippets;
export declare namespace Projects {
export {
type ProjectRetrieveResponse as ProjectRetrieveResponse,
type ProjectUpdateResponse as ProjectUpdateResponse,
+ type ProjectListResponse as ProjectListResponse,
type ProjectUpdateParams as ProjectUpdateParams,
+ type ProjectListParams as ProjectListParams,
};
export {
@@ -72,4 +131,18 @@ export declare namespace Projects {
type BranchCreateParams as BranchCreateParams,
type BranchRetrieveParams as BranchRetrieveParams,
};
+
+ export {
+ Configs as Configs,
+ type ConfigRetrieveResponse as ConfigRetrieveResponse,
+ type ConfigGuessResponse as ConfigGuessResponse,
+ type ConfigRetrieveParams as ConfigRetrieveParams,
+ type ConfigGuessParams as ConfigGuessParams,
+ };
+
+ export {
+ Snippets as Snippets,
+ type SnippetCreateRequestResponse as SnippetCreateRequestResponse,
+ type SnippetCreateRequestParams as SnippetCreateRequestParams,
+ };
}
diff --git a/src/resources/projects/snippets.ts b/src/resources/projects/snippets.ts
new file mode 100644
index 00000000..0b820c51
--- /dev/null
+++ b/src/resources/projects/snippets.ts
@@ -0,0 +1,74 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import { APIPromise } from '../../core/api-promise';
+import { RequestOptions } from '../../internal/request-options';
+import { path } from '../../internal/utils/path';
+
+export class Snippets extends APIResource {
+ createRequest(
+ projectName: string,
+ body: SnippetCreateRequestParams,
+ options?: RequestOptions,
+ ): APIPromise {
+ return this._client.post(path`/v0/projects/${projectName}/snippets/request`, { body, ...options });
+ }
+}
+
+export interface SnippetCreateRequestResponse {
+ snippet: string;
+}
+
+export interface SnippetCreateRequestParams {
+ language:
+ | 'node'
+ | 'typescript'
+ | 'python'
+ | 'go'
+ | 'java'
+ | 'kotlin'
+ | 'ruby'
+ | 'terraform'
+ | 'cli'
+ | 'php'
+ | 'csharp';
+
+ request: SnippetCreateRequestParams.Request;
+
+ version: 'next' | 'latest_released';
+}
+
+export namespace SnippetCreateRequestParams {
+ export interface Request {
+ method: string;
+
+ parameters: Array;
+
+ path: string;
+
+ body?: Request.Body;
+ }
+
+ export namespace Request {
+ export interface Parameter {
+ in: 'path' | 'query' | 'header' | 'cookie';
+
+ name: string;
+
+ value?: unknown;
+ }
+
+ export interface Body {
+ fileParam?: string;
+
+ filePath?: string;
+ }
+ }
+}
+
+export declare namespace Snippets {
+ export {
+ type SnippetCreateRequestResponse as SnippetCreateRequestResponse,
+ type SnippetCreateRequestParams as SnippetCreateRequestParams,
+ };
+}
diff --git a/src/version.ts b/src/version.ts
index b0bfd9e7..a528f635 100644
--- a/src/version.ts
+++ b/src/version.ts
@@ -1 +1 @@
-export const VERSION = '0.1.0-alpha.1'; // x-release-please-version
+export const VERSION = '0.1.0-alpha.2'; // x-release-please-version
diff --git a/tests/api-resources/builds.test.ts b/tests/api-resources/builds.test.ts
index fbbe6411..c6152795 100644
--- a/tests/api-resources/builds.test.ts
+++ b/tests/api-resources/builds.test.ts
@@ -61,9 +61,35 @@ describe('resource builds', () => {
const response = await client.builds.list({
project: 'project',
branch: 'branch',
- config_commit: 'config_commit',
cursor: 'cursor',
- limit: 0,
+ limit: 1,
+ revision: 'string',
+ });
+ });
+
+ // skipped: tests are disabled for the time being
+ test.skip('compare: only required params', async () => {
+ const responsePromise = client.builds.compare({
+ base: { revision: 'string' },
+ head: { revision: 'string' },
+ project: 'project',
+ });
+ const rawResponse = await responsePromise.asResponse();
+ expect(rawResponse).toBeInstanceOf(Response);
+ const response = await responsePromise;
+ expect(response).not.toBeInstanceOf(Response);
+ const dataAndResponse = await responsePromise.withResponse();
+ expect(dataAndResponse.data).toBe(response);
+ expect(dataAndResponse.response).toBe(rawResponse);
+ });
+
+ // skipped: tests are disabled for the time being
+ test.skip('compare: required and optional params', async () => {
+ const response = await client.builds.compare({
+ base: { revision: 'string', branch: 'branch', commit_message: 'commit_message' },
+ head: { revision: 'string', branch: 'branch', commit_message: 'commit_message' },
+ project: 'project',
+ targets: ['node'],
});
});
});
diff --git a/tests/api-resources/orgs.test.ts b/tests/api-resources/orgs.test.ts
new file mode 100644
index 00000000..93bb632a
--- /dev/null
+++ b/tests/api-resources/orgs.test.ts
@@ -0,0 +1,34 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import StainlessV0 from 'stainless-v0';
+
+const client = new StainlessV0({
+ apiKey: 'My API Key',
+ baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010',
+});
+
+describe('resource orgs', () => {
+ // skipped: tests are disabled for the time being
+ test.skip('retrieve', async () => {
+ const responsePromise = client.orgs.retrieve('orgName');
+ const rawResponse = await responsePromise.asResponse();
+ expect(rawResponse).toBeInstanceOf(Response);
+ const response = await responsePromise;
+ expect(response).not.toBeInstanceOf(Response);
+ const dataAndResponse = await responsePromise.withResponse();
+ expect(dataAndResponse.data).toBe(response);
+ expect(dataAndResponse.response).toBe(rawResponse);
+ });
+
+ // skipped: tests are disabled for the time being
+ test.skip('list', async () => {
+ const responsePromise = client.orgs.list();
+ const rawResponse = await responsePromise.asResponse();
+ expect(rawResponse).toBeInstanceOf(Response);
+ const response = await responsePromise;
+ expect(response).not.toBeInstanceOf(Response);
+ const dataAndResponse = await responsePromise.withResponse();
+ expect(dataAndResponse.data).toBe(response);
+ expect(dataAndResponse.response).toBe(rawResponse);
+ });
+});
diff --git a/tests/api-resources/projects/branches.test.ts b/tests/api-resources/projects/branches.test.ts
index f7ae2b33..736ea52a 100644
--- a/tests/api-resources/projects/branches.test.ts
+++ b/tests/api-resources/projects/branches.test.ts
@@ -28,6 +28,7 @@ describe('resource branches', () => {
const response = await client.projects.branches.create('project', {
branch: 'branch',
branch_from: 'branch_from',
+ force: true,
});
});
diff --git a/tests/api-resources/projects/configs.test.ts b/tests/api-resources/projects/configs.test.ts
new file mode 100644
index 00000000..7830874b
--- /dev/null
+++ b/tests/api-resources/projects/configs.test.ts
@@ -0,0 +1,47 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import StainlessV0 from 'stainless-v0';
+
+const client = new StainlessV0({
+ apiKey: 'My API Key',
+ baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010',
+});
+
+describe('resource configs', () => {
+ // skipped: tests are disabled for the time being
+ test.skip('retrieve', async () => {
+ const responsePromise = client.projects.configs.retrieve('project');
+ const rawResponse = await responsePromise.asResponse();
+ expect(rawResponse).toBeInstanceOf(Response);
+ const response = await responsePromise;
+ expect(response).not.toBeInstanceOf(Response);
+ const dataAndResponse = await responsePromise.withResponse();
+ expect(dataAndResponse.data).toBe(response);
+ expect(dataAndResponse.response).toBe(rawResponse);
+ });
+
+ // skipped: tests are disabled for the time being
+ test.skip('retrieve: request options and params are passed correctly', async () => {
+ // ensure the request options are being passed correctly by passing an invalid HTTP method in order to cause an error
+ await expect(
+ client.projects.configs.retrieve('project', { branch: 'branch' }, { path: '/_stainless_unknown_path' }),
+ ).rejects.toThrow(StainlessV0.NotFoundError);
+ });
+
+ // skipped: tests are disabled for the time being
+ test.skip('guess: only required params', async () => {
+ const responsePromise = client.projects.configs.guess('project', { spec: 'spec' });
+ const rawResponse = await responsePromise.asResponse();
+ expect(rawResponse).toBeInstanceOf(Response);
+ const response = await responsePromise;
+ expect(response).not.toBeInstanceOf(Response);
+ const dataAndResponse = await responsePromise.withResponse();
+ expect(dataAndResponse.data).toBe(response);
+ expect(dataAndResponse.response).toBe(rawResponse);
+ });
+
+ // skipped: tests are disabled for the time being
+ test.skip('guess: required and optional params', async () => {
+ const response = await client.projects.configs.guess('project', { spec: 'spec', branch: 'branch' });
+ });
+});
diff --git a/tests/api-resources/projects/projects.test.ts b/tests/api-resources/projects/projects.test.ts
index 80c95935..4356d012 100644
--- a/tests/api-resources/projects/projects.test.ts
+++ b/tests/api-resources/projects/projects.test.ts
@@ -43,4 +43,21 @@ describe('resource projects', () => {
),
).rejects.toThrow(StainlessV0.NotFoundError);
});
+
+ // skipped: tests are disabled for the time being
+ test.skip('list: only required params', async () => {
+ const responsePromise = client.projects.list({ org: 'org' });
+ const rawResponse = await responsePromise.asResponse();
+ expect(rawResponse).toBeInstanceOf(Response);
+ const response = await responsePromise;
+ expect(response).not.toBeInstanceOf(Response);
+ const dataAndResponse = await responsePromise.withResponse();
+ expect(dataAndResponse.data).toBe(response);
+ expect(dataAndResponse.response).toBe(rawResponse);
+ });
+
+ // skipped: tests are disabled for the time being
+ test.skip('list: required and optional params', async () => {
+ const response = await client.projects.list({ org: 'org', cursor: 'cursor', limit: 1 });
+ });
});
diff --git a/tests/api-resources/projects/snippets.test.ts b/tests/api-resources/projects/snippets.test.ts
new file mode 100644
index 00000000..14877391
--- /dev/null
+++ b/tests/api-resources/projects/snippets.test.ts
@@ -0,0 +1,40 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import StainlessV0 from 'stainless-v0';
+
+const client = new StainlessV0({
+ apiKey: 'My API Key',
+ baseURL: process.env['TEST_API_BASE_URL'] ?? 'http://127.0.0.1:4010',
+});
+
+describe('resource snippets', () => {
+ // skipped: tests are disabled for the time being
+ test.skip('createRequest: only required params', async () => {
+ const responsePromise = client.projects.snippets.createRequest('projectName', {
+ language: 'node',
+ request: { method: 'method', parameters: [{ in: 'path', name: 'name' }], path: 'path' },
+ version: 'next',
+ });
+ const rawResponse = await responsePromise.asResponse();
+ expect(rawResponse).toBeInstanceOf(Response);
+ const response = await responsePromise;
+ expect(response).not.toBeInstanceOf(Response);
+ const dataAndResponse = await responsePromise.withResponse();
+ expect(dataAndResponse.data).toBe(response);
+ expect(dataAndResponse.response).toBe(rawResponse);
+ });
+
+ // skipped: tests are disabled for the time being
+ test.skip('createRequest: required and optional params', async () => {
+ const response = await client.projects.snippets.createRequest('projectName', {
+ language: 'node',
+ request: {
+ method: 'method',
+ parameters: [{ in: 'path', name: 'name', value: {} }],
+ path: 'path',
+ body: { fileParam: 'fileParam', filePath: 'filePath' },
+ },
+ version: 'next',
+ });
+ });
+});
diff --git a/tests/index.test.ts b/tests/index.test.ts
index 7bcabeb3..71ba874f 100644
--- a/tests/index.test.ts
+++ b/tests/index.test.ts
@@ -325,6 +325,82 @@ describe('instantiate client', () => {
expect(client2.maxRetries).toEqual(2);
});
+ describe('withOptions', () => {
+ test('creates a new client with overridden options', () => {
+ const client = new StainlessV0({
+ baseURL: 'http://localhost:5000/',
+ maxRetries: 3,
+ apiKey: 'My API Key',
+ });
+
+ const newClient = client.withOptions({
+ maxRetries: 5,
+ baseURL: 'http://localhost:5001/',
+ });
+
+ // Verify the new client has updated options
+ expect(newClient.maxRetries).toEqual(5);
+ expect(newClient.baseURL).toEqual('http://localhost:5001/');
+
+ // Verify the original client is unchanged
+ expect(client.maxRetries).toEqual(3);
+ expect(client.baseURL).toEqual('http://localhost:5000/');
+
+ // Verify it's a different instance
+ expect(newClient).not.toBe(client);
+ expect(newClient.constructor).toBe(client.constructor);
+ });
+
+ test('inherits options from the parent client', () => {
+ const client = new StainlessV0({
+ baseURL: 'http://localhost:5000/',
+ defaultHeaders: { 'X-Test-Header': 'test-value' },
+ defaultQuery: { 'test-param': 'test-value' },
+ apiKey: 'My API Key',
+ });
+
+ const newClient = client.withOptions({
+ baseURL: 'http://localhost:5001/',
+ });
+
+ // Test inherited options remain the same
+ expect(newClient.buildURL('/foo', null)).toEqual('http://localhost:5001/foo?test-param=test-value');
+
+ const { req } = newClient.buildRequest({ path: '/foo', method: 'get' });
+ expect(req.headers.get('x-test-header')).toEqual('test-value');
+ });
+
+ test('respects runtime property changes when creating new client', () => {
+ const client = new StainlessV0({
+ baseURL: 'http://localhost:5000/',
+ timeout: 1000,
+ apiKey: 'My API Key',
+ });
+
+ // Modify the client properties directly after creation
+ client.baseURL = 'http://localhost:6000/';
+ client.timeout = 2000;
+
+ // Create a new client with withOptions
+ const newClient = client.withOptions({
+ maxRetries: 10,
+ });
+
+ // Verify the new client uses the updated properties, not the original ones
+ expect(newClient.baseURL).toEqual('http://localhost:6000/');
+ expect(newClient.timeout).toEqual(2000);
+ expect(newClient.maxRetries).toEqual(10);
+
+ // Original client should still have its modified properties
+ expect(client.baseURL).toEqual('http://localhost:6000/');
+ expect(client.timeout).toEqual(2000);
+ expect(client.maxRetries).not.toEqual(10);
+
+ // Verify URL building uses the updated baseURL
+ expect(newClient.buildURL('/bar', null)).toEqual('http://localhost:6000/bar');
+ });
+ });
+
test('with environment variable arguments', () => {
// set options via env var
process.env['STAINLESS_V0_API_KEY'] = 'My API Key';
diff --git a/tests/qs/empty-keys-cases.ts b/tests/qs/empty-keys-cases.ts
new file mode 100644
index 00000000..ea2c1b0a
--- /dev/null
+++ b/tests/qs/empty-keys-cases.ts
@@ -0,0 +1,271 @@
+export const empty_test_cases = [
+ {
+ input: '&',
+ with_empty_keys: {},
+ stringify_output: {
+ brackets: '',
+ indices: '',
+ repeat: '',
+ },
+ no_empty_keys: {},
+ },
+ {
+ input: '&&',
+ with_empty_keys: {},
+ stringify_output: {
+ brackets: '',
+ indices: '',
+ repeat: '',
+ },
+ no_empty_keys: {},
+ },
+ {
+ input: '&=',
+ with_empty_keys: { '': '' },
+ stringify_output: {
+ brackets: '=',
+ indices: '=',
+ repeat: '=',
+ },
+ no_empty_keys: {},
+ },
+ {
+ input: '&=&',
+ with_empty_keys: { '': '' },
+ stringify_output: {
+ brackets: '=',
+ indices: '=',
+ repeat: '=',
+ },
+ no_empty_keys: {},
+ },
+ {
+ input: '&=&=',
+ with_empty_keys: { '': ['', ''] },
+ stringify_output: {
+ brackets: '[]=&[]=',
+ indices: '[0]=&[1]=',
+ repeat: '=&=',
+ },
+ no_empty_keys: {},
+ },
+ {
+ input: '&=&=&',
+ with_empty_keys: { '': ['', ''] },
+ stringify_output: {
+ brackets: '[]=&[]=',
+ indices: '[0]=&[1]=',
+ repeat: '=&=',
+ },
+ no_empty_keys: {},
+ },
+ {
+ input: '=',
+ with_empty_keys: { '': '' },
+ no_empty_keys: {},
+ stringify_output: {
+ brackets: '=',
+ indices: '=',
+ repeat: '=',
+ },
+ },
+ {
+ input: '=&',
+ with_empty_keys: { '': '' },
+ stringify_output: {
+ brackets: '=',
+ indices: '=',
+ repeat: '=',
+ },
+ no_empty_keys: {},
+ },
+ {
+ input: '=&&&',
+ with_empty_keys: { '': '' },
+ stringify_output: {
+ brackets: '=',
+ indices: '=',
+ repeat: '=',
+ },
+ no_empty_keys: {},
+ },
+ {
+ input: '=&=&=&',
+ with_empty_keys: { '': ['', '', ''] },
+ stringify_output: {
+ brackets: '[]=&[]=&[]=',
+ indices: '[0]=&[1]=&[2]=',
+ repeat: '=&=&=',
+ },
+ no_empty_keys: {},
+ },
+ {
+ input: '=&a[]=b&a[1]=c',
+ with_empty_keys: { '': '', a: ['b', 'c'] },
+ stringify_output: {
+ brackets: '=&a[]=b&a[]=c',
+ indices: '=&a[0]=b&a[1]=c',
+ repeat: '=&a=b&a=c',
+ },
+ no_empty_keys: { a: ['b', 'c'] },
+ },
+ {
+ input: '=a',
+ with_empty_keys: { '': 'a' },
+ no_empty_keys: {},
+ stringify_output: {
+ brackets: '=a',
+ indices: '=a',
+ repeat: '=a',
+ },
+ },
+ {
+ input: 'a==a',
+ with_empty_keys: { a: '=a' },
+ no_empty_keys: { a: '=a' },
+ stringify_output: {
+ brackets: 'a==a',
+ indices: 'a==a',
+ repeat: 'a==a',
+ },
+ },
+ {
+ input: '=&a[]=b',
+ with_empty_keys: { '': '', a: ['b'] },
+ stringify_output: {
+ brackets: '=&a[]=b',
+ indices: '=&a[0]=b',
+ repeat: '=&a=b',
+ },
+ no_empty_keys: { a: ['b'] },
+ },
+ {
+ input: '=&a[]=b&a[]=c&a[2]=d',
+ with_empty_keys: { '': '', a: ['b', 'c', 'd'] },
+ stringify_output: {
+ brackets: '=&a[]=b&a[]=c&a[]=d',
+ indices: '=&a[0]=b&a[1]=c&a[2]=d',
+ repeat: '=&a=b&a=c&a=d',
+ },
+ no_empty_keys: { a: ['b', 'c', 'd'] },
+ },
+ {
+ input: '=a&=b',
+ with_empty_keys: { '': ['a', 'b'] },
+ stringify_output: {
+ brackets: '[]=a&[]=b',
+ indices: '[0]=a&[1]=b',
+ repeat: '=a&=b',
+ },
+ no_empty_keys: {},
+ },
+ {
+ input: '=a&foo=b',
+ with_empty_keys: { '': 'a', foo: 'b' },
+ no_empty_keys: { foo: 'b' },
+ stringify_output: {
+ brackets: '=a&foo=b',
+ indices: '=a&foo=b',
+ repeat: '=a&foo=b',
+ },
+ },
+ {
+ input: 'a[]=b&a=c&=',
+ with_empty_keys: { '': '', a: ['b', 'c'] },
+ stringify_output: {
+ brackets: '=&a[]=b&a[]=c',
+ indices: '=&a[0]=b&a[1]=c',
+ repeat: '=&a=b&a=c',
+ },
+ no_empty_keys: { a: ['b', 'c'] },
+ },
+ {
+ input: 'a[]=b&a=c&=',
+ with_empty_keys: { '': '', a: ['b', 'c'] },
+ stringify_output: {
+ brackets: '=&a[]=b&a[]=c',
+ indices: '=&a[0]=b&a[1]=c',
+ repeat: '=&a=b&a=c',
+ },
+ no_empty_keys: { a: ['b', 'c'] },
+ },
+ {
+ input: 'a[0]=b&a=c&=',
+ with_empty_keys: { '': '', a: ['b', 'c'] },
+ stringify_output: {
+ brackets: '=&a[]=b&a[]=c',
+ indices: '=&a[0]=b&a[1]=c',
+ repeat: '=&a=b&a=c',
+ },
+ no_empty_keys: { a: ['b', 'c'] },
+ },
+ {
+ input: 'a=b&a[]=c&=',
+ with_empty_keys: { '': '', a: ['b', 'c'] },
+ stringify_output: {
+ brackets: '=&a[]=b&a[]=c',
+ indices: '=&a[0]=b&a[1]=c',
+ repeat: '=&a=b&a=c',
+ },
+ no_empty_keys: { a: ['b', 'c'] },
+ },
+ {
+ input: 'a=b&a[0]=c&=',
+ with_empty_keys: { '': '', a: ['b', 'c'] },
+ stringify_output: {
+ brackets: '=&a[]=b&a[]=c',
+ indices: '=&a[0]=b&a[1]=c',
+ repeat: '=&a=b&a=c',
+ },
+ no_empty_keys: { a: ['b', 'c'] },
+ },
+ {
+ input: '[]=a&[]=b& []=1',
+ with_empty_keys: { '': ['a', 'b'], ' ': ['1'] },
+ stringify_output: {
+ brackets: '[]=a&[]=b& []=1',
+ indices: '[0]=a&[1]=b& [0]=1',
+ repeat: '=a&=b& =1',
+ },
+ no_empty_keys: { 0: 'a', 1: 'b', ' ': ['1'] },
+ },
+ {
+ input: '[0]=a&[1]=b&a[0]=1&a[1]=2',
+ with_empty_keys: { '': ['a', 'b'], a: ['1', '2'] },
+ no_empty_keys: { 0: 'a', 1: 'b', a: ['1', '2'] },
+ stringify_output: {
+ brackets: '[]=a&[]=b&a[]=1&a[]=2',
+ indices: '[0]=a&[1]=b&a[0]=1&a[1]=2',
+ repeat: '=a&=b&a=1&a=2',
+ },
+ },
+ {
+ input: '[deep]=a&[deep]=2',
+ with_empty_keys: { '': { deep: ['a', '2'] } },
+ stringify_output: {
+ brackets: '[deep][]=a&[deep][]=2',
+ indices: '[deep][0]=a&[deep][1]=2',
+ repeat: '[deep]=a&[deep]=2',
+ },
+ no_empty_keys: { deep: ['a', '2'] },
+ },
+ {
+ input: '%5B0%5D=a&%5B1%5D=b',
+ with_empty_keys: { '': ['a', 'b'] },
+ stringify_output: {
+ brackets: '[]=a&[]=b',
+ indices: '[0]=a&[1]=b',
+ repeat: '=a&=b',
+ },
+ no_empty_keys: { 0: 'a', 1: 'b' },
+ },
+] satisfies {
+ input: string;
+ with_empty_keys: Record;
+ stringify_output: {
+ brackets: string;
+ indices: string;
+ repeat: string;
+ };
+ no_empty_keys: Record;
+}[];
diff --git a/tests/qs/stringify.test.ts b/tests/qs/stringify.test.ts
new file mode 100644
index 00000000..ab6697bc
--- /dev/null
+++ b/tests/qs/stringify.test.ts
@@ -0,0 +1,2232 @@
+import iconv from 'iconv-lite';
+import { stringify } from 'stainless-v0/internal/qs';
+import { encode } from 'stainless-v0/internal/qs/utils';
+import { StringifyOptions } from 'stainless-v0/internal/qs/types';
+import { empty_test_cases } from './empty-keys-cases';
+import assert from 'assert';
+
+describe('stringify()', function () {
+ test('stringifies a querystring object', function () {
+ expect(stringify({ a: 'b' })).toBe('a=b');
+ expect(stringify({ a: 1 })).toBe('a=1');
+ expect(stringify({ a: 1, b: 2 })).toBe('a=1&b=2');
+ expect(stringify({ a: 'A_Z' })).toBe('a=A_Z');
+ expect(stringify({ a: '€' })).toBe('a=%E2%82%AC');
+ expect(stringify({ a: '' })).toBe('a=%EE%80%80');
+ expect(stringify({ a: 'א' })).toBe('a=%D7%90');
+ expect(stringify({ a: '𐐷' })).toBe('a=%F0%90%90%B7');
+ });
+
+ test('stringifies falsy values', function () {
+ expect(stringify(undefined)).toBe('');
+ expect(stringify(null)).toBe('');
+ expect(stringify(null, { strictNullHandling: true })).toBe('');
+ expect(stringify(false)).toBe('');
+ expect(stringify(0)).toBe('');
+ });
+
+ test('stringifies symbols', function () {
+ expect(stringify(Symbol.iterator)).toBe('');
+ expect(stringify([Symbol.iterator])).toBe('0=Symbol%28Symbol.iterator%29');
+ expect(stringify({ a: Symbol.iterator })).toBe('a=Symbol%28Symbol.iterator%29');
+ expect(stringify({ a: [Symbol.iterator] }, { encodeValuesOnly: true, arrayFormat: 'brackets' })).toBe(
+ 'a[]=Symbol%28Symbol.iterator%29',
+ );
+ });
+
+ test('stringifies bigints', function () {
+ var three = BigInt(3);
+ // @ts-expect-error
+ var encodeWithN = function (value, defaultEncoder, charset) {
+ var result = defaultEncoder(value, defaultEncoder, charset);
+ return typeof value === 'bigint' ? result + 'n' : result;
+ };
+
+ expect(stringify(three)).toBe('');
+ expect(stringify([three])).toBe('0=3');
+ expect(stringify([three], { encoder: encodeWithN })).toBe('0=3n');
+ expect(stringify({ a: three })).toBe('a=3');
+ expect(stringify({ a: three }, { encoder: encodeWithN })).toBe('a=3n');
+ expect(stringify({ a: [three] }, { encodeValuesOnly: true, arrayFormat: 'brackets' })).toBe('a[]=3');
+ expect(
+ stringify({ a: [three] }, { encodeValuesOnly: true, encoder: encodeWithN, arrayFormat: 'brackets' }),
+ ).toBe('a[]=3n');
+ });
+
+ test('encodes dot in key of object when encodeDotInKeys and allowDots is provided', function () {
+ expect(
+ stringify({ 'name.obj': { first: 'John', last: 'Doe' } }, { allowDots: false, encodeDotInKeys: false }),
+ ).toBe('name.obj%5Bfirst%5D=John&name.obj%5Blast%5D=Doe');
+ expect(
+ stringify({ 'name.obj': { first: 'John', last: 'Doe' } }, { allowDots: true, encodeDotInKeys: false }),
+ ).toBe('name.obj.first=John&name.obj.last=Doe');
+ expect(
+ stringify({ 'name.obj': { first: 'John', last: 'Doe' } }, { allowDots: false, encodeDotInKeys: true }),
+ ).toBe('name%252Eobj%5Bfirst%5D=John&name%252Eobj%5Blast%5D=Doe');
+ expect(
+ stringify({ 'name.obj': { first: 'John', last: 'Doe' } }, { allowDots: true, encodeDotInKeys: true }),
+ ).toBe('name%252Eobj.first=John&name%252Eobj.last=Doe');
+
+ // st.equal(
+ // stringify(
+ // { 'name.obj.subobject': { 'first.godly.name': 'John', last: 'Doe' } },
+ // { allowDots: false, encodeDotInKeys: false },
+ // ),
+ // 'name.obj.subobject%5Bfirst.godly.name%5D=John&name.obj.subobject%5Blast%5D=Doe',
+ // 'with allowDots false and encodeDotInKeys false',
+ // );
+ // st.equal(
+ // stringify(
+ // { 'name.obj.subobject': { 'first.godly.name': 'John', last: 'Doe' } },
+ // { allowDots: true, encodeDotInKeys: false },
+ // ),
+ // 'name.obj.subobject.first.godly.name=John&name.obj.subobject.last=Doe',
+ // 'with allowDots false and encodeDotInKeys false',
+ // );
+ // st.equal(
+ // stringify(
+ // { 'name.obj.subobject': { 'first.godly.name': 'John', last: 'Doe' } },
+ // { allowDots: false, encodeDotInKeys: true },
+ // ),
+ // 'name%252Eobj%252Esubobject%5Bfirst.godly.name%5D=John&name%252Eobj%252Esubobject%5Blast%5D=Doe',
+ // 'with allowDots false and encodeDotInKeys true',
+ // );
+ // st.equal(
+ // stringify(
+ // { 'name.obj.subobject': { 'first.godly.name': 'John', last: 'Doe' } },
+ // { allowDots: true, encodeDotInKeys: true },
+ // ),
+ // 'name%252Eobj%252Esubobject.first%252Egodly%252Ename=John&name%252Eobj%252Esubobject.last=Doe',
+ // 'with allowDots true and encodeDotInKeys true',
+ // );
+ expect(
+ stringify(
+ { 'name.obj.subobject': { 'first.godly.name': 'John', last: 'Doe' } },
+ { allowDots: false, encodeDotInKeys: false },
+ ),
+ ).toBe('name.obj.subobject%5Bfirst.godly.name%5D=John&name.obj.subobject%5Blast%5D=Doe');
+ expect(
+ stringify(
+ { 'name.obj.subobject': { 'first.godly.name': 'John', last: 'Doe' } },
+ { allowDots: true, encodeDotInKeys: false },
+ ),
+ ).toBe('name.obj.subobject.first.godly.name=John&name.obj.subobject.last=Doe');
+ expect(
+ stringify(
+ { 'name.obj.subobject': { 'first.godly.name': 'John', last: 'Doe' } },
+ { allowDots: false, encodeDotInKeys: true },
+ ),
+ ).toBe('name%252Eobj%252Esubobject%5Bfirst.godly.name%5D=John&name%252Eobj%252Esubobject%5Blast%5D=Doe');
+ expect(
+ stringify(
+ { 'name.obj.subobject': { 'first.godly.name': 'John', last: 'Doe' } },
+ { allowDots: true, encodeDotInKeys: true },
+ ),
+ ).toBe('name%252Eobj%252Esubobject.first%252Egodly%252Ename=John&name%252Eobj%252Esubobject.last=Doe');
+ });
+
+ test('should encode dot in key of object, and automatically set allowDots to `true` when encodeDotInKeys is true and allowDots in undefined', function () {
+ // st.equal(
+ // stringify(
+ // { 'name.obj.subobject': { 'first.godly.name': 'John', last: 'Doe' } },
+ // { encodeDotInKeys: true },
+ // ),
+ // 'name%252Eobj%252Esubobject.first%252Egodly%252Ename=John&name%252Eobj%252Esubobject.last=Doe',
+ // 'with allowDots undefined and encodeDotInKeys true',
+ // );
+ expect(
+ stringify(
+ { 'name.obj.subobject': { 'first.godly.name': 'John', last: 'Doe' } },
+ { encodeDotInKeys: true },
+ ),
+ ).toBe('name%252Eobj%252Esubobject.first%252Egodly%252Ename=John&name%252Eobj%252Esubobject.last=Doe');
+ });
+
+ test('should encode dot in key of object when encodeDotInKeys and allowDots is provided, and nothing else when encodeValuesOnly is provided', function () {
+ // st.equal(
+ // stringify(
+ // { 'name.obj': { first: 'John', last: 'Doe' } },
+ // {
+ // encodeDotInKeys: true,
+ // allowDots: true,
+ // encodeValuesOnly: true,
+ // },
+ // ),
+ // 'name%2Eobj.first=John&name%2Eobj.last=Doe',
+ // );
+ expect(
+ stringify(
+ { 'name.obj': { first: 'John', last: 'Doe' } },
+ {
+ encodeDotInKeys: true,
+ allowDots: true,
+ encodeValuesOnly: true,
+ },
+ ),
+ ).toBe('name%2Eobj.first=John&name%2Eobj.last=Doe');
+
+ // st.equal(
+ // stringify(
+ // { 'name.obj.subobject': { 'first.godly.name': 'John', last: 'Doe' } },
+ // { allowDots: true, encodeDotInKeys: true, encodeValuesOnly: true },
+ // ),
+ // 'name%2Eobj%2Esubobject.first%2Egodly%2Ename=John&name%2Eobj%2Esubobject.last=Doe',
+ // );
+ expect(
+ stringify(
+ { 'name.obj.subobject': { 'first.godly.name': 'John', last: 'Doe' } },
+ { allowDots: true, encodeDotInKeys: true, encodeValuesOnly: true },
+ ),
+ ).toBe('name%2Eobj%2Esubobject.first%2Egodly%2Ename=John&name%2Eobj%2Esubobject.last=Doe');
+ });
+
+ test('throws when `commaRoundTrip` is not a boolean', function () {
+ // st['throws'](
+ // function () {
+ // stringify({}, { commaRoundTrip: 'not a boolean' });
+ // },
+ // TypeError,
+ // 'throws when `commaRoundTrip` is not a boolean',
+ // );
+ expect(() => {
+ // @ts-expect-error
+ stringify({}, { commaRoundTrip: 'not a boolean' });
+ }).toThrow(TypeError);
+ });
+
+ test('throws when `encodeDotInKeys` is not a boolean', function () {
+ // st['throws'](function () {
+ // stringify({ a: [], b: 'zz' }, { encodeDotInKeys: 'foobar' });
+ // }, TypeError);
+ expect(() => {
+ // @ts-expect-error
+ stringify({ a: [], b: 'zz' }, { encodeDotInKeys: 'foobar' });
+ }).toThrow(TypeError);
+
+ // st['throws'](function () {
+ // stringify({ a: [], b: 'zz' }, { encodeDotInKeys: 0 });
+ // }, TypeError);
+ expect(() => {
+ // @ts-expect-error
+ stringify({ a: [], b: 'zz' }, { encodeDotInKeys: 0 });
+ }).toThrow(TypeError);
+
+ // st['throws'](function () {
+ // stringify({ a: [], b: 'zz' }, { encodeDotInKeys: NaN });
+ // }, TypeError);
+ expect(() => {
+ // @ts-expect-error
+ stringify({ a: [], b: 'zz' }, { encodeDotInKeys: NaN });
+ }).toThrow(TypeError);
+
+ // st['throws'](function () {
+ // stringify({ a: [], b: 'zz' }, { encodeDotInKeys: null });
+ // }, TypeError);
+ expect(() => {
+ // @ts-expect-error
+ stringify({ a: [], b: 'zz' }, { encodeDotInKeys: null });
+ }).toThrow(TypeError);
+ });
+
+ test('adds query prefix', function () {
+ // st.equal(stringify({ a: 'b' }, { addQueryPrefix: true }), '?a=b');
+ expect(stringify({ a: 'b' }, { addQueryPrefix: true })).toBe('?a=b');
+ });
+
+ test('with query prefix, outputs blank string given an empty object', function () {
+ // st.equal(stringify({}, { addQueryPrefix: true }), '');
+ expect(stringify({}, { addQueryPrefix: true })).toBe('');
+ });
+
+ test('stringifies nested falsy values', function () {
+ // st.equal(stringify({ a: { b: { c: null } } }), 'a%5Bb%5D%5Bc%5D=');
+ // st.equal(
+ // stringify({ a: { b: { c: null } } }, { strictNullHandling: true }),
+ // 'a%5Bb%5D%5Bc%5D',
+ // );
+ // st.equal(stringify({ a: { b: { c: false } } }), 'a%5Bb%5D%5Bc%5D=false');
+ expect(stringify({ a: { b: { c: null } } })).toBe('a%5Bb%5D%5Bc%5D=');
+ expect(stringify({ a: { b: { c: null } } }, { strictNullHandling: true })).toBe('a%5Bb%5D%5Bc%5D');
+ expect(stringify({ a: { b: { c: false } } })).toBe('a%5Bb%5D%5Bc%5D=false');
+ });
+
+ test('stringifies a nested object', function () {
+ // st.equal(stringify({ a: { b: 'c' } }), 'a%5Bb%5D=c');
+ // st.equal(stringify({ a: { b: { c: { d: 'e' } } } }), 'a%5Bb%5D%5Bc%5D%5Bd%5D=e');
+ expect(stringify({ a: { b: 'c' } })).toBe('a%5Bb%5D=c');
+ expect(stringify({ a: { b: { c: { d: 'e' } } } })).toBe('a%5Bb%5D%5Bc%5D%5Bd%5D=e');
+ });
+
+ test('`allowDots` option: stringifies a nested object with dots notation', function () {
+ // st.equal(stringify({ a: { b: 'c' } }, { allowDots: true }), 'a.b=c');
+ // st.equal(stringify({ a: { b: { c: { d: 'e' } } } }, { allowDots: true }), 'a.b.c.d=e');
+ expect(stringify({ a: { b: 'c' } }, { allowDots: true })).toBe('a.b=c');
+ expect(stringify({ a: { b: { c: { d: 'e' } } } }, { allowDots: true })).toBe('a.b.c.d=e');
+ });
+
+ test('stringifies an array value', function () {
+ // st.equal(
+ // stringify({ a: ['b', 'c', 'd'] }, { arrayFormat: 'indices' }),
+ // 'a%5B0%5D=b&a%5B1%5D=c&a%5B2%5D=d',
+ // 'indices => indices',
+ // );
+ // st.equal(
+ // stringify({ a: ['b', 'c', 'd'] }, { arrayFormat: 'brackets' }),
+ // 'a%5B%5D=b&a%5B%5D=c&a%5B%5D=d',
+ // 'brackets => brackets',
+ // );
+ // st.equal(
+ // stringify({ a: ['b', 'c', 'd'] }, { arrayFormat: 'comma' }),
+ // 'a=b%2Cc%2Cd',
+ // 'comma => comma',
+ // );
+ // st.equal(
+ // stringify({ a: ['b', 'c', 'd'] }, { arrayFormat: 'comma', commaRoundTrip: true }),
+ // 'a=b%2Cc%2Cd',
+ // 'comma round trip => comma',
+ // );
+ // st.equal(
+ // stringify({ a: ['b', 'c', 'd'] }),
+ // 'a%5B0%5D=b&a%5B1%5D=c&a%5B2%5D=d',
+ // 'default => indices',
+ // );
+ expect(stringify({ a: ['b', 'c', 'd'] }, { arrayFormat: 'indices' })).toBe(
+ 'a%5B0%5D=b&a%5B1%5D=c&a%5B2%5D=d',
+ );
+ expect(stringify({ a: ['b', 'c', 'd'] }, { arrayFormat: 'brackets' })).toBe(
+ 'a%5B%5D=b&a%5B%5D=c&a%5B%5D=d',
+ );
+ expect(stringify({ a: ['b', 'c', 'd'] }, { arrayFormat: 'comma' })).toBe('a=b%2Cc%2Cd');
+ expect(stringify({ a: ['b', 'c', 'd'] }, { arrayFormat: 'comma', commaRoundTrip: true })).toBe(
+ 'a=b%2Cc%2Cd',
+ );
+ expect(stringify({ a: ['b', 'c', 'd'] })).toBe('a%5B0%5D=b&a%5B1%5D=c&a%5B2%5D=d');
+ });
+
+ test('`skipNulls` option', function () {
+ // st.equal(
+ // stringify({ a: 'b', c: null }, { skipNulls: true }),
+ // 'a=b',
+ // 'omits nulls when asked',
+ // );
+ expect(stringify({ a: 'b', c: null }, { skipNulls: true })).toBe('a=b');
+
+ // st.equal(
+ // stringify({ a: { b: 'c', d: null } }, { skipNulls: true }),
+ // 'a%5Bb%5D=c',
+ // 'omits nested nulls when asked',
+ // );
+ expect(stringify({ a: { b: 'c', d: null } }, { skipNulls: true })).toBe('a%5Bb%5D=c');
+ });
+
+ test('omits array indices when asked', function () {
+ // st.equal(stringify({ a: ['b', 'c', 'd'] }, { indices: false }), 'a=b&a=c&a=d');
+ expect(stringify({ a: ['b', 'c', 'd'] }, { indices: false })).toBe('a=b&a=c&a=d');
+ });
+
+ test('omits object key/value pair when value is empty array', function () {
+ // st.equal(stringify({ a: [], b: 'zz' }), 'b=zz');
+ expect(stringify({ a: [], b: 'zz' })).toBe('b=zz');
+ });
+
+ test('should not omit object key/value pair when value is empty array and when asked', function () {
+ // st.equal(stringify({ a: [], b: 'zz' }), 'b=zz');
+ // st.equal(stringify({ a: [], b: 'zz' }, { allowEmptyArrays: false }), 'b=zz');
+ // st.equal(stringify({ a: [], b: 'zz' }, { allowEmptyArrays: true }), 'a[]&b=zz');
+ expect(stringify({ a: [], b: 'zz' })).toBe('b=zz');
+ expect(stringify({ a: [], b: 'zz' }, { allowEmptyArrays: false })).toBe('b=zz');
+ expect(stringify({ a: [], b: 'zz' }, { allowEmptyArrays: true })).toBe('a[]&b=zz');
+ });
+
+ test('should throw when allowEmptyArrays is not of type boolean', function () {
+ // st['throws'](function () {
+ // stringify({ a: [], b: 'zz' }, { allowEmptyArrays: 'foobar' });
+ // }, TypeError);
+ expect(() => {
+ // @ts-expect-error
+ stringify({ a: [], b: 'zz' }, { allowEmptyArrays: 'foobar' });
+ }).toThrow(TypeError);
+
+ // st['throws'](function () {
+ // stringify({ a: [], b: 'zz' }, { allowEmptyArrays: 0 });
+ // }, TypeError);
+ expect(() => {
+ // @ts-expect-error
+ stringify({ a: [], b: 'zz' }, { allowEmptyArrays: 0 });
+ }).toThrow(TypeError);
+
+ // st['throws'](function () {
+ // stringify({ a: [], b: 'zz' }, { allowEmptyArrays: NaN });
+ // }, TypeError);
+ expect(() => {
+ // @ts-expect-error
+ stringify({ a: [], b: 'zz' }, { allowEmptyArrays: NaN });
+ }).toThrow(TypeError);
+
+ // st['throws'](function () {
+ // stringify({ a: [], b: 'zz' }, { allowEmptyArrays: null });
+ // }, TypeError);
+ expect(() => {
+ // @ts-expect-error
+ stringify({ a: [], b: 'zz' }, { allowEmptyArrays: null });
+ }).toThrow(TypeError);
+ });
+
+ test('allowEmptyArrays + strictNullHandling', function () {
+ // st.equal(
+ // stringify({ testEmptyArray: [] }, { strictNullHandling: true, allowEmptyArrays: true }),
+ // 'testEmptyArray[]',
+ // );
+ expect(stringify({ testEmptyArray: [] }, { strictNullHandling: true, allowEmptyArrays: true })).toBe(
+ 'testEmptyArray[]',
+ );
+ });
+
+ describe('stringifies an array value with one item vs multiple items', function () {
+ test('non-array item', function () {
+ // s2t.equal(
+ // stringify({ a: 'c' }, { encodeValuesOnly: true, arrayFormat: 'indices' }),
+ // 'a=c',
+ // );
+ // s2t.equal(
+ // stringify({ a: 'c' }, { encodeValuesOnly: true, arrayFormat: 'brackets' }),
+ // 'a=c',
+ // );
+ // s2t.equal(stringify({ a: 'c' }, { encodeValuesOnly: true, arrayFormat: 'comma' }), 'a=c');
+ // s2t.equal(stringify({ a: 'c' }, { encodeValuesOnly: true }), 'a=c');
+ expect(stringify({ a: 'c' }, { encodeValuesOnly: true, arrayFormat: 'indices' })).toBe('a=c');
+ expect(stringify({ a: 'c' }, { encodeValuesOnly: true, arrayFormat: 'brackets' })).toBe('a=c');
+ expect(stringify({ a: 'c' }, { encodeValuesOnly: true, arrayFormat: 'comma' })).toBe('a=c');
+ expect(stringify({ a: 'c' }, { encodeValuesOnly: true })).toBe('a=c');
+ });
+
+ test('array with a single item', function () {
+ // s2t.equal(
+ // stringify({ a: ['c'] }, { encodeValuesOnly: true, arrayFormat: 'indices' }),
+ // 'a[0]=c',
+ // );
+ // s2t.equal(
+ // stringify({ a: ['c'] }, { encodeValuesOnly: true, arrayFormat: 'brackets' }),
+ // 'a[]=c',
+ // );
+ // s2t.equal(
+ // stringify({ a: ['c'] }, { encodeValuesOnly: true, arrayFormat: 'comma' }),
+ // 'a=c',
+ // );
+ // s2t.equal(
+ // stringify(
+ // { a: ['c'] },
+ // { encodeValuesOnly: true, arrayFormat: 'comma', commaRoundTrip: true },
+ // ),
+ // 'a[]=c',
+ // ); // so it parses back as an array
+ // s2t.equal(stringify({ a: ['c'] }, { encodeValuesOnly: true }), 'a[0]=c');
+ expect(stringify({ a: ['c'] }, { encodeValuesOnly: true, arrayFormat: 'indices' })).toBe('a[0]=c');
+ expect(stringify({ a: ['c'] }, { encodeValuesOnly: true, arrayFormat: 'brackets' })).toBe('a[]=c');
+ expect(stringify({ a: ['c'] }, { encodeValuesOnly: true, arrayFormat: 'comma' })).toBe('a=c');
+ expect(
+ stringify({ a: ['c'] }, { encodeValuesOnly: true, arrayFormat: 'comma', commaRoundTrip: true }),
+ ).toBe('a[]=c');
+ expect(stringify({ a: ['c'] }, { encodeValuesOnly: true })).toBe('a[0]=c');
+ });
+
+ test('array with multiple items', function () {
+ // s2t.equal(
+ // stringify({ a: ['c', 'd'] }, { encodeValuesOnly: true, arrayFormat: 'indices' }),
+ // 'a[0]=c&a[1]=d',
+ // );
+ // s2t.equal(
+ // stringify({ a: ['c', 'd'] }, { encodeValuesOnly: true, arrayFormat: 'brackets' }),
+ // 'a[]=c&a[]=d',
+ // );
+ // s2t.equal(
+ // stringify({ a: ['c', 'd'] }, { encodeValuesOnly: true, arrayFormat: 'comma' }),
+ // 'a=c,d',
+ // );
+ // s2t.equal(
+ // stringify(
+ // { a: ['c', 'd'] },
+ // { encodeValuesOnly: true, arrayFormat: 'comma', commaRoundTrip: true },
+ // ),
+ // 'a=c,d',
+ // );
+ // s2t.equal(stringify({ a: ['c', 'd'] }, { encodeValuesOnly: true }), 'a[0]=c&a[1]=d');
+ expect(stringify({ a: ['c', 'd'] }, { encodeValuesOnly: true, arrayFormat: 'indices' })).toBe(
+ 'a[0]=c&a[1]=d',
+ );
+ expect(stringify({ a: ['c', 'd'] }, { encodeValuesOnly: true, arrayFormat: 'brackets' })).toBe(
+ 'a[]=c&a[]=d',
+ );
+ expect(stringify({ a: ['c', 'd'] }, { encodeValuesOnly: true, arrayFormat: 'comma' })).toBe('a=c,d');
+ expect(
+ stringify({ a: ['c', 'd'] }, { encodeValuesOnly: true, arrayFormat: 'comma', commaRoundTrip: true }),
+ ).toBe('a=c,d');
+ expect(stringify({ a: ['c', 'd'] }, { encodeValuesOnly: true })).toBe('a[0]=c&a[1]=d');
+ });
+
+ test('array with multiple items with a comma inside', function () {
+ // s2t.equal(
+ // stringify({ a: ['c,d', 'e'] }, { encodeValuesOnly: true, arrayFormat: 'comma' }),
+ // 'a=c%2Cd,e',
+ // );
+ // s2t.equal(stringify({ a: ['c,d', 'e'] }, { arrayFormat: 'comma' }), 'a=c%2Cd%2Ce');
+ expect(stringify({ a: ['c,d', 'e'] }, { encodeValuesOnly: true, arrayFormat: 'comma' })).toBe(
+ 'a=c%2Cd,e',
+ );
+ expect(stringify({ a: ['c,d', 'e'] }, { arrayFormat: 'comma' })).toBe('a=c%2Cd%2Ce');
+
+ // s2t.equal(
+ // stringify(
+ // { a: ['c,d', 'e'] },
+ // { encodeValuesOnly: true, arrayFormat: 'comma', commaRoundTrip: true },
+ // ),
+ // 'a=c%2Cd,e',
+ // );
+ // s2t.equal(
+ // stringify({ a: ['c,d', 'e'] }, { arrayFormat: 'comma', commaRoundTrip: true }),
+ // 'a=c%2Cd%2Ce',
+ // );
+ expect(
+ stringify(
+ { a: ['c,d', 'e'] },
+ { encodeValuesOnly: true, arrayFormat: 'comma', commaRoundTrip: true },
+ ),
+ ).toBe('a=c%2Cd,e');
+ expect(stringify({ a: ['c,d', 'e'] }, { arrayFormat: 'comma', commaRoundTrip: true })).toBe(
+ 'a=c%2Cd%2Ce',
+ );
+ });
+ });
+
+ test('stringifies a nested array value', function () {
+ expect(stringify({ a: { b: ['c', 'd'] } }, { encodeValuesOnly: true, arrayFormat: 'indices' })).toBe(
+ 'a[b][0]=c&a[b][1]=d',
+ );
+ expect(stringify({ a: { b: ['c', 'd'] } }, { encodeValuesOnly: true, arrayFormat: 'brackets' })).toBe(
+ 'a[b][]=c&a[b][]=d',
+ );
+ expect(stringify({ a: { b: ['c', 'd'] } }, { encodeValuesOnly: true, arrayFormat: 'comma' })).toBe(
+ 'a[b]=c,d',
+ );
+ expect(stringify({ a: { b: ['c', 'd'] } }, { encodeValuesOnly: true })).toBe('a[b][0]=c&a[b][1]=d');
+ });
+
+ test('stringifies comma and empty array values', function () {
+ // st.equal(
+ // stringify({ a: [',', '', 'c,d%'] }, { encode: false, arrayFormat: 'indices' }),
+ // 'a[0]=,&a[1]=&a[2]=c,d%',
+ // );
+ // st.equal(
+ // stringify({ a: [',', '', 'c,d%'] }, { encode: false, arrayFormat: 'brackets' }),
+ // 'a[]=,&a[]=&a[]=c,d%',
+ // );
+ // st.equal(
+ // stringify({ a: [',', '', 'c,d%'] }, { encode: false, arrayFormat: 'comma' }),
+ // 'a=,,,c,d%',
+ // );
+ // st.equal(
+ // stringify({ a: [',', '', 'c,d%'] }, { encode: false, arrayFormat: 'repeat' }),
+ // 'a=,&a=&a=c,d%',
+ // );
+ expect(stringify({ a: [',', '', 'c,d%'] }, { encode: false, arrayFormat: 'indices' })).toBe(
+ 'a[0]=,&a[1]=&a[2]=c,d%',
+ );
+ expect(stringify({ a: [',', '', 'c,d%'] }, { encode: false, arrayFormat: 'brackets' })).toBe(
+ 'a[]=,&a[]=&a[]=c,d%',
+ );
+ expect(stringify({ a: [',', '', 'c,d%'] }, { encode: false, arrayFormat: 'comma' })).toBe('a=,,,c,d%');
+ expect(stringify({ a: [',', '', 'c,d%'] }, { encode: false, arrayFormat: 'repeat' })).toBe(
+ 'a=,&a=&a=c,d%',
+ );
+
+ // st.equal(
+ // stringify(
+ // { a: [',', '', 'c,d%'] },
+ // { encode: true, encodeValuesOnly: true, arrayFormat: 'indices' },
+ // ),
+ // 'a[0]=%2C&a[1]=&a[2]=c%2Cd%25',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [',', '', 'c,d%'] },
+ // { encode: true, encodeValuesOnly: true, arrayFormat: 'brackets' },
+ // ),
+ // 'a[]=%2C&a[]=&a[]=c%2Cd%25',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [',', '', 'c,d%'] },
+ // { encode: true, encodeValuesOnly: true, arrayFormat: 'comma' },
+ // ),
+ // 'a=%2C,,c%2Cd%25',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [',', '', 'c,d%'] },
+ // { encode: true, encodeValuesOnly: true, arrayFormat: 'repeat' },
+ // ),
+ // 'a=%2C&a=&a=c%2Cd%25',
+ // );
+ expect(
+ stringify({ a: [',', '', 'c,d%'] }, { encode: true, encodeValuesOnly: false, arrayFormat: 'indices' }),
+ ).toBe('a%5B0%5D=%2C&a%5B1%5D=&a%5B2%5D=c%2Cd%25');
+ expect(
+ stringify({ a: [',', '', 'c,d%'] }, { encode: true, encodeValuesOnly: true, arrayFormat: 'brackets' }),
+ ).toBe('a[]=%2C&a[]=&a[]=c%2Cd%25');
+ expect(
+ stringify({ a: [',', '', 'c,d%'] }, { encode: true, encodeValuesOnly: false, arrayFormat: 'comma' }),
+ ).toBe('a=%2C%2C%2Cc%2Cd%25');
+ expect(
+ stringify({ a: [',', '', 'c,d%'] }, { encode: true, encodeValuesOnly: false, arrayFormat: 'repeat' }),
+ ).toBe('a=%2C&a=&a=c%2Cd%25');
+
+ // st.equal(
+ // stringify(
+ // { a: [',', '', 'c,d%'] },
+ // { encode: true, encodeValuesOnly: false, arrayFormat: 'indices' },
+ // ),
+ // 'a%5B0%5D=%2C&a%5B1%5D=&a%5B2%5D=c%2Cd%25',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [',', '', 'c,d%'] },
+ // { encode: true, encodeValuesOnly: false, arrayFormat: 'brackets' },
+ // ),
+ // 'a%5B%5D=%2C&a%5B%5D=&a%5B%5D=c%2Cd%25',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [',', '', 'c,d%'] },
+ // { encode: true, encodeValuesOnly: false, arrayFormat: 'comma' },
+ // ),
+ // 'a=%2C%2C%2Cc%2Cd%25',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [',', '', 'c,d%'] },
+ // { encode: true, encodeValuesOnly: false, arrayFormat: 'repeat' },
+ // ),
+ // 'a=%2C&a=&a=c%2Cd%25',
+ // );
+ expect(
+ stringify({ a: [',', '', 'c,d%'] }, { encode: true, encodeValuesOnly: false, arrayFormat: 'repeat' }),
+ ).toBe('a=%2C&a=&a=c%2Cd%25');
+ expect(
+ stringify({ a: [',', '', 'c,d%'] }, { encode: true, encodeValuesOnly: false, arrayFormat: 'indices' }),
+ ).toBe('a%5B0%5D=%2C&a%5B1%5D=&a%5B2%5D=c%2Cd%25');
+ expect(
+ stringify({ a: [',', '', 'c,d%'] }, { encode: true, encodeValuesOnly: true, arrayFormat: 'brackets' }),
+ ).toBe('a[]=%2C&a[]=&a[]=c%2Cd%25');
+ expect(
+ stringify({ a: [',', '', 'c,d%'] }, { encode: true, encodeValuesOnly: false, arrayFormat: 'comma' }),
+ ).toBe('a=%2C%2C%2Cc%2Cd%25');
+ expect(
+ stringify({ a: [',', '', 'c,d%'] }, { encode: true, encodeValuesOnly: false, arrayFormat: 'repeat' }),
+ ).toBe('a=%2C&a=&a=c%2Cd%25');
+ });
+
+ test('stringifies comma and empty non-array values', function () {
+ // st.equal(
+ // stringify({ a: ',', b: '', c: 'c,d%' }, { encode: false, arrayFormat: 'indices' }),
+ // 'a=,&b=&c=c,d%',
+ // );
+ // st.equal(
+ // stringify({ a: ',', b: '', c: 'c,d%' }, { encode: false, arrayFormat: 'brackets' }),
+ // 'a=,&b=&c=c,d%',
+ // );
+ // st.equal(
+ // stringify({ a: ',', b: '', c: 'c,d%' }, { encode: false, arrayFormat: 'comma' }),
+ // 'a=,&b=&c=c,d%',
+ // );
+ // st.equal(
+ // stringify({ a: ',', b: '', c: 'c,d%' }, { encode: false, arrayFormat: 'repeat' }),
+ // 'a=,&b=&c=c,d%',
+ // );
+ expect(stringify({ a: ',', b: '', c: 'c,d%' }, { encode: false, arrayFormat: 'indices' })).toBe(
+ 'a=,&b=&c=c,d%',
+ );
+ expect(stringify({ a: ',', b: '', c: 'c,d%' }, { encode: false, arrayFormat: 'brackets' })).toBe(
+ 'a=,&b=&c=c,d%',
+ );
+
+ // st.equal(
+ // stringify(
+ // { a: ',', b: '', c: 'c,d%' },
+ // { encode: true, encodeValuesOnly: true, arrayFormat: 'indices' },
+ // ),
+ // 'a=%2C&b=&c=c%2Cd%25',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: ',', b: '', c: 'c,d%' },
+ // { encode: true, encodeValuesOnly: true, arrayFormat: 'brackets' },
+ // ),
+ // 'a=%2C&b=&c=c%2Cd%25',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: ',', b: '', c: 'c,d%' },
+ // { encode: true, encodeValuesOnly: true, arrayFormat: 'comma' },
+ // ),
+ // 'a=%2C&b=&c=c%2Cd%25',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: ',', b: '', c: 'c,d%' },
+ // { encode: true, encodeValuesOnly: true, arrayFormat: 'repeat' },
+ // ),
+ // 'a=%2C&b=&c=c%2Cd%25',
+ // );
+ expect(
+ stringify(
+ { a: ',', b: '', c: 'c,d%' },
+ { encode: true, encodeValuesOnly: true, arrayFormat: 'indices' },
+ ),
+ ).toBe('a=%2C&b=&c=c%2Cd%25');
+ expect(
+ stringify(
+ { a: ',', b: '', c: 'c,d%' },
+ { encode: true, encodeValuesOnly: true, arrayFormat: 'brackets' },
+ ),
+ ).toBe('a=%2C&b=&c=c%2Cd%25');
+ expect(
+ stringify({ a: ',', b: '', c: 'c,d%' }, { encode: true, encodeValuesOnly: true, arrayFormat: 'comma' }),
+ ).toBe('a=%2C&b=&c=c%2Cd%25');
+ expect(
+ stringify(
+ { a: ',', b: '', c: 'c,d%' },
+ { encode: true, encodeValuesOnly: true, arrayFormat: 'repeat' },
+ ),
+ ).toBe('a=%2C&b=&c=c%2Cd%25');
+
+ // st.equal(
+ // stringify(
+ // { a: ',', b: '', c: 'c,d%' },
+ // { encode: true, encodeValuesOnly: false, arrayFormat: 'indices' },
+ // ),
+ // 'a=%2C&b=&c=c%2Cd%25',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: ',', b: '', c: 'c,d%' },
+ // { encode: true, encodeValuesOnly: false, arrayFormat: 'brackets' },
+ // ),
+ // 'a=%2C&b=&c=c%2Cd%25',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: ',', b: '', c: 'c,d%' },
+ // { encode: true, encodeValuesOnly: false, arrayFormat: 'comma' },
+ // ),
+ // 'a=%2C&b=&c=c%2Cd%25',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: ',', b: '', c: 'c,d%' },
+ // { encode: true, encodeValuesOnly: false, arrayFormat: 'repeat' },
+ // ),
+ // 'a=%2C&b=&c=c%2Cd%25',
+ // );
+ expect(
+ stringify(
+ { a: ',', b: '', c: 'c,d%' },
+ { encode: true, encodeValuesOnly: false, arrayFormat: 'indices' },
+ ),
+ ).toBe('a=%2C&b=&c=c%2Cd%25');
+ expect(
+ stringify(
+ { a: ',', b: '', c: 'c,d%' },
+ { encode: true, encodeValuesOnly: false, arrayFormat: 'brackets' },
+ ),
+ ).toBe('a=%2C&b=&c=c%2Cd%25');
+ expect(
+ stringify(
+ { a: ',', b: '', c: 'c,d%' },
+ { encode: true, encodeValuesOnly: false, arrayFormat: 'comma' },
+ ),
+ ).toBe('a=%2C&b=&c=c%2Cd%25');
+ expect(
+ stringify(
+ { a: ',', b: '', c: 'c,d%' },
+ { encode: true, encodeValuesOnly: false, arrayFormat: 'repeat' },
+ ),
+ ).toBe('a=%2C&b=&c=c%2Cd%25');
+ });
+
+ test('stringifies a nested array value with dots notation', function () {
+ // st.equal(
+ // stringify(
+ // { a: { b: ['c', 'd'] } },
+ // { allowDots: true, encodeValuesOnly: true, arrayFormat: 'indices' },
+ // ),
+ // 'a.b[0]=c&a.b[1]=d',
+ // 'indices: stringifies with dots + indices',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: { b: ['c', 'd'] } },
+ // { allowDots: true, encodeValuesOnly: true, arrayFormat: 'brackets' },
+ // ),
+ // 'a.b[]=c&a.b[]=d',
+ // 'brackets: stringifies with dots + brackets',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: { b: ['c', 'd'] } },
+ // { allowDots: true, encodeValuesOnly: true, arrayFormat: 'comma' },
+ // ),
+ // 'a.b=c,d',
+ // 'comma: stringifies with dots + comma',
+ // );
+ // st.equal(
+ // stringify({ a: { b: ['c', 'd'] } }, { allowDots: true, encodeValuesOnly: true }),
+ // 'a.b[0]=c&a.b[1]=d',
+ // 'default: stringifies with dots + indices',
+ // );
+ expect(
+ stringify(
+ { a: { b: ['c', 'd'] } },
+ { allowDots: true, encodeValuesOnly: true, arrayFormat: 'indices' },
+ ),
+ ).toBe('a.b[0]=c&a.b[1]=d');
+ expect(
+ stringify(
+ { a: { b: ['c', 'd'] } },
+ { allowDots: true, encodeValuesOnly: true, arrayFormat: 'brackets' },
+ ),
+ ).toBe('a.b[]=c&a.b[]=d');
+ expect(
+ stringify({ a: { b: ['c', 'd'] } }, { allowDots: true, encodeValuesOnly: true, arrayFormat: 'comma' }),
+ ).toBe('a.b=c,d');
+ expect(stringify({ a: { b: ['c', 'd'] } }, { allowDots: true, encodeValuesOnly: true })).toBe(
+ 'a.b[0]=c&a.b[1]=d',
+ );
+ });
+
+ test('stringifies an object inside an array', function () {
+ // st.equal(
+ // stringify({ a: [{ b: 'c' }] }, { arrayFormat: 'indices', encodeValuesOnly: true }),
+ // 'a[0][b]=c',
+ // 'indices => indices',
+ // );
+ // st.equal(
+ // stringify({ a: [{ b: 'c' }] }, { arrayFormat: 'repeat', encodeValuesOnly: true }),
+ // 'a[b]=c',
+ // 'repeat => repeat',
+ // );
+ // st.equal(
+ // stringify({ a: [{ b: 'c' }] }, { arrayFormat: 'brackets', encodeValuesOnly: true }),
+ // 'a[][b]=c',
+ // 'brackets => brackets',
+ // );
+ // st.equal(
+ // stringify({ a: [{ b: 'c' }] }, { encodeValuesOnly: true }),
+ // 'a[0][b]=c',
+ // 'default => indices',
+ // );
+ expect(stringify({ a: [{ b: 'c' }] }, { arrayFormat: 'indices', encodeValuesOnly: true })).toBe(
+ 'a[0][b]=c',
+ );
+ expect(stringify({ a: [{ b: 'c' }] }, { arrayFormat: 'repeat', encodeValuesOnly: true })).toBe('a[b]=c');
+ expect(stringify({ a: [{ b: 'c' }] }, { arrayFormat: 'brackets', encodeValuesOnly: true })).toBe(
+ 'a[][b]=c',
+ );
+ expect(stringify({ a: [{ b: 'c' }] }, { encodeValuesOnly: true })).toBe('a[0][b]=c');
+
+ // st.equal(
+ // stringify({ a: [{ b: { c: [1] } }] }, { arrayFormat: 'indices', encodeValuesOnly: true }),
+ // 'a[0][b][c][0]=1',
+ // 'indices => indices',
+ // );
+ // st.equal(
+ // stringify({ a: [{ b: { c: [1] } }] }, { arrayFormat: 'repeat', encodeValuesOnly: true }),
+ // 'a[b][c]=1',
+ // 'repeat => repeat',
+ // );
+ // st.equal(
+ // stringify({ a: [{ b: { c: [1] } }] }, { arrayFormat: 'brackets', encodeValuesOnly: true }),
+ // 'a[][b][c][]=1',
+ // 'brackets => brackets',
+ // );
+ // st.equal(
+ // stringify({ a: [{ b: { c: [1] } }] }, { encodeValuesOnly: true }),
+ // 'a[0][b][c][0]=1',
+ // 'default => indices',
+ // );
+ expect(stringify({ a: [{ b: { c: [1] } }] }, { arrayFormat: 'indices', encodeValuesOnly: true })).toBe(
+ 'a[0][b][c][0]=1',
+ );
+ expect(stringify({ a: [{ b: { c: [1] } }] }, { arrayFormat: 'repeat', encodeValuesOnly: true })).toBe(
+ 'a[b][c]=1',
+ );
+ expect(stringify({ a: [{ b: { c: [1] } }] }, { arrayFormat: 'brackets', encodeValuesOnly: true })).toBe(
+ 'a[][b][c][]=1',
+ );
+ expect(stringify({ a: [{ b: { c: [1] } }] }, { encodeValuesOnly: true })).toBe('a[0][b][c][0]=1');
+ });
+
+ test('stringifies an array with mixed objects and primitives', function () {
+ // st.equal(
+ // stringify({ a: [{ b: 1 }, 2, 3] }, { encodeValuesOnly: true, arrayFormat: 'indices' }),
+ // 'a[0][b]=1&a[1]=2&a[2]=3',
+ // 'indices => indices',
+ // );
+ // st.equal(
+ // stringify({ a: [{ b: 1 }, 2, 3] }, { encodeValuesOnly: true, arrayFormat: 'brackets' }),
+ // 'a[][b]=1&a[]=2&a[]=3',
+ // 'brackets => brackets',
+ // );
+ // st.equal(
+ // stringify({ a: [{ b: 1 }, 2, 3] }, { encodeValuesOnly: true, arrayFormat: 'comma' }),
+ // '???',
+ // 'brackets => brackets',
+ // { skip: 'TODO: figure out what this should do' },
+ // );
+ // st.equal(
+ // stringify({ a: [{ b: 1 }, 2, 3] }, { encodeValuesOnly: true }),
+ // 'a[0][b]=1&a[1]=2&a[2]=3',
+ // 'default => indices',
+ // );
+ expect(stringify({ a: [{ b: 1 }, 2, 3] }, { encodeValuesOnly: true, arrayFormat: 'indices' })).toBe(
+ 'a[0][b]=1&a[1]=2&a[2]=3',
+ );
+ expect(stringify({ a: [{ b: 1 }, 2, 3] }, { encodeValuesOnly: true, arrayFormat: 'brackets' })).toBe(
+ 'a[][b]=1&a[]=2&a[]=3',
+ );
+ // !Skipped: Figure out what this should do
+ // expect(
+ // stringify({ a: [{ b: 1 }, 2, 3] }, { encodeValuesOnly: true, arrayFormat: 'comma' }),
+ // ).toBe('???');
+ expect(stringify({ a: [{ b: 1 }, 2, 3] }, { encodeValuesOnly: true })).toBe('a[0][b]=1&a[1]=2&a[2]=3');
+ });
+
+ test('stringifies an object inside an array with dots notation', function () {
+ // st.equal(
+ // stringify({ a: [{ b: 'c' }] }, { allowDots: true, encode: false, arrayFormat: 'indices' }),
+ // 'a[0].b=c',
+ // 'indices => indices',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [{ b: 'c' }] },
+ // { allowDots: true, encode: false, arrayFormat: 'brackets' },
+ // ),
+ // 'a[].b=c',
+ // 'brackets => brackets',
+ // );
+ // st.equal(
+ // stringify({ a: [{ b: 'c' }] }, { allowDots: true, encode: false }),
+ // 'a[0].b=c',
+ // 'default => indices',
+ // );
+ expect(stringify({ a: [{ b: 'c' }] }, { allowDots: true, encode: false, arrayFormat: 'indices' })).toBe(
+ 'a[0].b=c',
+ );
+ expect(stringify({ a: [{ b: 'c' }] }, { allowDots: true, encode: false, arrayFormat: 'brackets' })).toBe(
+ 'a[].b=c',
+ );
+ expect(stringify({ a: [{ b: 'c' }] }, { allowDots: true, encode: false })).toBe('a[0].b=c');
+
+ // st.equal(
+ // stringify(
+ // { a: [{ b: { c: [1] } }] },
+ // { allowDots: true, encode: false, arrayFormat: 'indices' },
+ // ),
+ // 'a[0].b.c[0]=1',
+ // 'indices => indices',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [{ b: { c: [1] } }] },
+ // { allowDots: true, encode: false, arrayFormat: 'brackets' },
+ // ),
+ // 'a[].b.c[]=1',
+ // 'brackets => brackets',
+ // );
+ // st.equal(
+ // stringify({ a: [{ b: { c: [1] } }] }, { allowDots: true, encode: false }),
+ // 'a[0].b.c[0]=1',
+ // 'default => indices',
+ // );
+ expect(
+ stringify({ a: [{ b: { c: [1] } }] }, { allowDots: true, encode: false, arrayFormat: 'indices' }),
+ ).toBe('a[0].b.c[0]=1');
+ expect(
+ stringify({ a: [{ b: { c: [1] } }] }, { allowDots: true, encode: false, arrayFormat: 'brackets' }),
+ ).toBe('a[].b.c[]=1');
+ expect(stringify({ a: [{ b: { c: [1] } }] }, { allowDots: true, encode: false })).toBe('a[0].b.c[0]=1');
+ });
+
+ test('does not omit object keys when indices = false', function () {
+ // st.equal(stringify({ a: [{ b: 'c' }] }, { indices: false }), 'a%5Bb%5D=c');
+ expect(stringify({ a: [{ b: 'c' }] }, { indices: false })).toBe('a%5Bb%5D=c');
+ });
+
+ test('uses indices notation for arrays when indices=true', function () {
+ // st.equal(stringify({ a: ['b', 'c'] }, { indices: true }), 'a%5B0%5D=b&a%5B1%5D=c');
+ expect(stringify({ a: ['b', 'c'] }, { indices: true })).toBe('a%5B0%5D=b&a%5B1%5D=c');
+ });
+
+ test('uses indices notation for arrays when no arrayFormat is specified', function () {
+ // st.equal(stringify({ a: ['b', 'c'] }), 'a%5B0%5D=b&a%5B1%5D=c');
+ expect(stringify({ a: ['b', 'c'] })).toBe('a%5B0%5D=b&a%5B1%5D=c');
+ });
+
+ test('uses indices notation for arrays when arrayFormat=indices', function () {
+ // st.equal(stringify({ a: ['b', 'c'] }, { arrayFormat: 'indices' }), 'a%5B0%5D=b&a%5B1%5D=c');
+ expect(stringify({ a: ['b', 'c'] }, { arrayFormat: 'indices' })).toBe('a%5B0%5D=b&a%5B1%5D=c');
+ });
+
+ test('uses repeat notation for arrays when arrayFormat=repeat', function () {
+ // st.equal(stringify({ a: ['b', 'c'] }, { arrayFormat: 'repeat' }), 'a=b&a=c');
+ expect(stringify({ a: ['b', 'c'] }, { arrayFormat: 'repeat' })).toBe('a=b&a=c');
+ });
+
+ test('uses brackets notation for arrays when arrayFormat=brackets', function () {
+ // st.equal(stringify({ a: ['b', 'c'] }, { arrayFormat: 'brackets' }), 'a%5B%5D=b&a%5B%5D=c');
+ expect(stringify({ a: ['b', 'c'] }, { arrayFormat: 'brackets' })).toBe('a%5B%5D=b&a%5B%5D=c');
+ });
+
+ test('stringifies a complicated object', function () {
+ // st.equal(stringify({ a: { b: 'c', d: 'e' } }), 'a%5Bb%5D=c&a%5Bd%5D=e');
+ expect(stringify({ a: { b: 'c', d: 'e' } })).toBe('a%5Bb%5D=c&a%5Bd%5D=e');
+ });
+
+ test('stringifies an empty value', function () {
+ // st.equal(stringify({ a: '' }), 'a=');
+ // st.equal(stringify({ a: null }, { strictNullHandling: true }), 'a');
+ expect(stringify({ a: '' })).toBe('a=');
+ expect(stringify({ a: null }, { strictNullHandling: true })).toBe('a');
+
+ // st.equal(stringify({ a: '', b: '' }), 'a=&b=');
+ // st.equal(stringify({ a: null, b: '' }, { strictNullHandling: true }), 'a&b=');
+ expect(stringify({ a: '', b: '' })).toBe('a=&b=');
+ expect(stringify({ a: null, b: '' }, { strictNullHandling: true })).toBe('a&b=');
+
+ // st.equal(stringify({ a: { b: '' } }), 'a%5Bb%5D=');
+ // st.equal(stringify({ a: { b: null } }, { strictNullHandling: true }), 'a%5Bb%5D');
+ // st.equal(stringify({ a: { b: null } }, { strictNullHandling: false }), 'a%5Bb%5D=');
+ expect(stringify({ a: { b: '' } })).toBe('a%5Bb%5D=');
+ expect(stringify({ a: { b: null } }, { strictNullHandling: true })).toBe('a%5Bb%5D');
+ expect(stringify({ a: { b: null } }, { strictNullHandling: false })).toBe('a%5Bb%5D=');
+ });
+
+ test('stringifies an empty array in different arrayFormat', function () {
+ // st.equal(stringify({ a: [], b: [null], c: 'c' }, { encode: false }), 'b[0]=&c=c');
+ expect(stringify({ a: [], b: [null], c: 'c' }, { encode: false })).toBe('b[0]=&c=c');
+ // arrayFormat default
+ // st.equal(
+ // stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'indices' }),
+ // 'b[0]=&c=c',
+ // );
+ // st.equal(
+ // stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'brackets' }),
+ // 'b[]=&c=c',
+ // );
+ // st.equal(
+ // stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'repeat' }),
+ // 'b=&c=c',
+ // );
+ // st.equal(
+ // stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'comma' }),
+ // 'b=&c=c',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [], b: [null], c: 'c' },
+ // { encode: false, arrayFormat: 'comma', commaRoundTrip: true },
+ // ),
+ // 'b[]=&c=c',
+ // );
+ expect(stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'indices' })).toBe(
+ 'b[0]=&c=c',
+ );
+ expect(stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'brackets' })).toBe(
+ 'b[]=&c=c',
+ );
+ expect(stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'repeat' })).toBe('b=&c=c');
+ expect(stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'comma' })).toBe('b=&c=c');
+ expect(
+ stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'comma', commaRoundTrip: true }),
+ ).toBe('b[]=&c=c');
+
+ // with strictNullHandling
+ // st.equal(
+ // stringify(
+ // { a: [], b: [null], c: 'c' },
+ // { encode: false, arrayFormat: 'indices', strictNullHandling: true },
+ // ),
+ // 'b[0]&c=c',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [], b: [null], c: 'c' },
+ // { encode: false, arrayFormat: 'brackets', strictNullHandling: true },
+ // ),
+ // 'b[]&c=c',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [], b: [null], c: 'c' },
+ // { encode: false, arrayFormat: 'repeat', strictNullHandling: true },
+ // ),
+ // 'b&c=c',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [], b: [null], c: 'c' },
+ // { encode: false, arrayFormat: 'comma', strictNullHandling: true },
+ // ),
+ // 'b&c=c',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [], b: [null], c: 'c' },
+ // { encode: false, arrayFormat: 'comma', strictNullHandling: true, commaRoundTrip: true },
+ // ),
+ // 'b[]&c=c',
+ // );
+
+ expect(
+ stringify(
+ { a: [], b: [null], c: 'c' },
+ { encode: false, arrayFormat: 'indices', strictNullHandling: true },
+ ),
+ ).toBe('b[0]&c=c');
+ expect(
+ stringify(
+ { a: [], b: [null], c: 'c' },
+ { encode: false, arrayFormat: 'brackets', strictNullHandling: true },
+ ),
+ ).toBe('b[]&c=c');
+ expect(
+ stringify(
+ { a: [], b: [null], c: 'c' },
+ { encode: false, arrayFormat: 'repeat', strictNullHandling: true },
+ ),
+ ).toBe('b&c=c');
+ expect(
+ stringify(
+ { a: [], b: [null], c: 'c' },
+ { encode: false, arrayFormat: 'comma', strictNullHandling: true },
+ ),
+ ).toBe('b&c=c');
+ expect(
+ stringify(
+ { a: [], b: [null], c: 'c' },
+ { encode: false, arrayFormat: 'comma', strictNullHandling: true, commaRoundTrip: true },
+ ),
+ ).toBe('b[]&c=c');
+
+ // with skipNulls
+ // st.equal(
+ // stringify(
+ // { a: [], b: [null], c: 'c' },
+ // { encode: false, arrayFormat: 'indices', skipNulls: true },
+ // ),
+ // 'c=c',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [], b: [null], c: 'c' },
+ // { encode: false, arrayFormat: 'brackets', skipNulls: true },
+ // ),
+ // 'c=c',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [], b: [null], c: 'c' },
+ // { encode: false, arrayFormat: 'repeat', skipNulls: true },
+ // ),
+ // 'c=c',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [], b: [null], c: 'c' },
+ // { encode: false, arrayFormat: 'comma', skipNulls: true },
+ // ),
+ // 'c=c',
+ // );
+ expect(
+ stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'indices', skipNulls: true }),
+ ).toBe('c=c');
+ expect(
+ stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'brackets', skipNulls: true }),
+ ).toBe('c=c');
+ expect(
+ stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'repeat', skipNulls: true }),
+ ).toBe('c=c');
+ expect(
+ stringify({ a: [], b: [null], c: 'c' }, { encode: false, arrayFormat: 'comma', skipNulls: true }),
+ ).toBe('c=c');
+ });
+
+ test('stringifies a null object', function () {
+ var obj = Object.create(null);
+ obj.a = 'b';
+ // st.equal(stringify(obj), 'a=b');
+ expect(stringify(obj)).toBe('a=b');
+ });
+
+ test('returns an empty string for invalid input', function () {
+ // st.equal(stringify(undefined), '');
+ // st.equal(stringify(false), '');
+ // st.equal(stringify(null), '');
+ // st.equal(stringify(''), '');
+ expect(stringify(undefined)).toBe('');
+ expect(stringify(false)).toBe('');
+ expect(stringify(null)).toBe('');
+ expect(stringify('')).toBe('');
+ });
+
+ test('stringifies an object with a null object as a child', function () {
+ var obj = { a: Object.create(null) };
+
+ obj.a.b = 'c';
+ // st.equal(stringify(obj), 'a%5Bb%5D=c');
+ expect(stringify(obj)).toBe('a%5Bb%5D=c');
+ });
+
+ test('drops keys with a value of undefined', function () {
+ // st.equal(stringify({ a: undefined }), '');
+ expect(stringify({ a: undefined })).toBe('');
+
+ // st.equal(
+ // stringify({ a: { b: undefined, c: null } }, { strictNullHandling: true }),
+ // 'a%5Bc%5D',
+ // );
+ // st.equal(
+ // stringify({ a: { b: undefined, c: null } }, { strictNullHandling: false }),
+ // 'a%5Bc%5D=',
+ // );
+ // st.equal(stringify({ a: { b: undefined, c: '' } }), 'a%5Bc%5D=');
+ expect(stringify({ a: { b: undefined, c: null } }, { strictNullHandling: true })).toBe('a%5Bc%5D');
+ expect(stringify({ a: { b: undefined, c: null } }, { strictNullHandling: false })).toBe('a%5Bc%5D=');
+ expect(stringify({ a: { b: undefined, c: '' } })).toBe('a%5Bc%5D=');
+ });
+
+ test('url encodes values', function () {
+ // st.equal(stringify({ a: 'b c' }), 'a=b%20c');
+ expect(stringify({ a: 'b c' })).toBe('a=b%20c');
+ });
+
+ test('stringifies a date', function () {
+ var now = new Date();
+ var str = 'a=' + encodeURIComponent(now.toISOString());
+ // st.equal(stringify({ a: now }), str);
+ expect(stringify({ a: now })).toBe(str);
+ });
+
+ test('stringifies the weird object from qs', function () {
+ // st.equal(
+ // stringify({ 'my weird field': '~q1!2"\'w$5&7/z8)?' }),
+ // 'my%20weird%20field=~q1%212%22%27w%245%267%2Fz8%29%3F',
+ // );
+ expect(stringify({ 'my weird field': '~q1!2"\'w$5&7/z8)?' })).toBe(
+ 'my%20weird%20field=~q1%212%22%27w%245%267%2Fz8%29%3F',
+ );
+ });
+
+ // TODO: Investigate how to to intercept in vitest
+ // TODO(rob)
+ test('skips properties that are part of the object prototype', function () {
+ // st.intercept(Object.prototype, 'crash', { value: 'test' });
+ // @ts-expect-error
+ Object.prototype.crash = 'test';
+
+ // st.equal(stringify({ a: 'b' }), 'a=b');
+ // st.equal(stringify({ a: { b: 'c' } }), 'a%5Bb%5D=c');
+ expect(stringify({ a: 'b' })).toBe('a=b');
+ expect(stringify({ a: { b: 'c' } })).toBe('a%5Bb%5D=c');
+ });
+
+ test('stringifies boolean values', function () {
+ // st.equal(stringify({ a: true }), 'a=true');
+ // st.equal(stringify({ a: { b: true } }), 'a%5Bb%5D=true');
+ // st.equal(stringify({ b: false }), 'b=false');
+ // st.equal(stringify({ b: { c: false } }), 'b%5Bc%5D=false');
+ expect(stringify({ a: true })).toBe('a=true');
+ expect(stringify({ a: { b: true } })).toBe('a%5Bb%5D=true');
+ expect(stringify({ b: false })).toBe('b=false');
+ expect(stringify({ b: { c: false } })).toBe('b%5Bc%5D=false');
+ });
+
+ test('stringifies buffer values', function () {
+ // st.equal(stringify({ a: Buffer.from('test') }), 'a=test');
+ // st.equal(stringify({ a: { b: Buffer.from('test') } }), 'a%5Bb%5D=test');
+ });
+
+ test('stringifies an object using an alternative delimiter', function () {
+ // st.equal(stringify({ a: 'b', c: 'd' }, { delimiter: ';' }), 'a=b;c=d');
+ expect(stringify({ a: 'b', c: 'd' }, { delimiter: ';' })).toBe('a=b;c=d');
+ });
+
+ // We dont target environments which dont even have Buffer
+ // test('does not blow up when Buffer global is missing', function () {
+ // var restore = mockProperty(global, 'Buffer', { delete: true });
+
+ // var result = stringify({ a: 'b', c: 'd' });
+
+ // restore();
+
+ // st.equal(result, 'a=b&c=d');
+ // st.end();
+ // });
+
+ test('does not crash when parsing circular references', function () {
+ var a: any = {};
+ a.b = a;
+
+ // st['throws'](
+ // function () {
+ // stringify({ 'foo[bar]': 'baz', 'foo[baz]': a });
+ // },
+ // /RangeError: Cyclic object value/,
+ // 'cyclic values throw',
+ // );
+ expect(() => {
+ stringify({ 'foo[bar]': 'baz', 'foo[baz]': a });
+ }).toThrow('Cyclic object value');
+
+ var circular: any = {
+ a: 'value',
+ };
+ circular.a = circular;
+ // st['throws'](
+ // function () {
+ // stringify(circular);
+ // },
+ // /RangeError: Cyclic object value/,
+ // 'cyclic values throw',
+ // );
+ expect(() => {
+ stringify(circular);
+ }).toThrow('Cyclic object value');
+
+ var arr = ['a'];
+ // st.doesNotThrow(function () {
+ // stringify({ x: arr, y: arr });
+ // }, 'non-cyclic values do not throw');
+ expect(() => {
+ stringify({ x: arr, y: arr });
+ }).not.toThrow();
+ });
+
+ test('non-circular duplicated references can still work', function () {
+ var hourOfDay = {
+ function: 'hour_of_day',
+ };
+
+ var p1 = {
+ function: 'gte',
+ arguments: [hourOfDay, 0],
+ };
+ var p2 = {
+ function: 'lte',
+ arguments: [hourOfDay, 23],
+ };
+
+ // st.equal(
+ // stringify(
+ // { filters: { $and: [p1, p2] } },
+ // { encodeValuesOnly: true, arrayFormat: 'indices' },
+ // ),
+ // 'filters[$and][0][function]=gte&filters[$and][0][arguments][0][function]=hour_of_day&filters[$and][0][arguments][1]=0&filters[$and][1][function]=lte&filters[$and][1][arguments][0][function]=hour_of_day&filters[$and][1][arguments][1]=23',
+ // );
+ // st.equal(
+ // stringify(
+ // { filters: { $and: [p1, p2] } },
+ // { encodeValuesOnly: true, arrayFormat: 'brackets' },
+ // ),
+ // 'filters[$and][][function]=gte&filters[$and][][arguments][][function]=hour_of_day&filters[$and][][arguments][]=0&filters[$and][][function]=lte&filters[$and][][arguments][][function]=hour_of_day&filters[$and][][arguments][]=23',
+ // );
+ // st.equal(
+ // stringify(
+ // { filters: { $and: [p1, p2] } },
+ // { encodeValuesOnly: true, arrayFormat: 'repeat' },
+ // ),
+ // 'filters[$and][function]=gte&filters[$and][arguments][function]=hour_of_day&filters[$and][arguments]=0&filters[$and][function]=lte&filters[$and][arguments][function]=hour_of_day&filters[$and][arguments]=23',
+ // );
+ expect(
+ stringify({ filters: { $and: [p1, p2] } }, { encodeValuesOnly: true, arrayFormat: 'indices' }),
+ ).toBe(
+ 'filters[$and][0][function]=gte&filters[$and][0][arguments][0][function]=hour_of_day&filters[$and][0][arguments][1]=0&filters[$and][1][function]=lte&filters[$and][1][arguments][0][function]=hour_of_day&filters[$and][1][arguments][1]=23',
+ );
+ expect(
+ stringify({ filters: { $and: [p1, p2] } }, { encodeValuesOnly: true, arrayFormat: 'brackets' }),
+ ).toBe(
+ 'filters[$and][][function]=gte&filters[$and][][arguments][][function]=hour_of_day&filters[$and][][arguments][]=0&filters[$and][][function]=lte&filters[$and][][arguments][][function]=hour_of_day&filters[$and][][arguments][]=23',
+ );
+ expect(
+ stringify({ filters: { $and: [p1, p2] } }, { encodeValuesOnly: true, arrayFormat: 'repeat' }),
+ ).toBe(
+ 'filters[$and][function]=gte&filters[$and][arguments][function]=hour_of_day&filters[$and][arguments]=0&filters[$and][function]=lte&filters[$and][arguments][function]=hour_of_day&filters[$and][arguments]=23',
+ );
+ });
+
+ test('selects properties when filter=array', function () {
+ // st.equal(stringify({ a: 'b' }, { filter: ['a'] }), 'a=b');
+ // st.equal(stringify({ a: 1 }, { filter: [] }), '');
+ expect(stringify({ a: 'b' }, { filter: ['a'] })).toBe('a=b');
+ expect(stringify({ a: 1 }, { filter: [] })).toBe('');
+
+ // st.equal(
+ // stringify(
+ // { a: { b: [1, 2, 3, 4], c: 'd' }, c: 'f' },
+ // { filter: ['a', 'b', 0, 2], arrayFormat: 'indices' },
+ // ),
+ // 'a%5Bb%5D%5B0%5D=1&a%5Bb%5D%5B2%5D=3',
+ // 'indices => indices',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: { b: [1, 2, 3, 4], c: 'd' }, c: 'f' },
+ // { filter: ['a', 'b', 0, 2], arrayFormat: 'brackets' },
+ // ),
+ // 'a%5Bb%5D%5B%5D=1&a%5Bb%5D%5B%5D=3',
+ // 'brackets => brackets',
+ // );
+ // st.equal(
+ // stringify({ a: { b: [1, 2, 3, 4], c: 'd' }, c: 'f' }, { filter: ['a', 'b', 0, 2] }),
+ // 'a%5Bb%5D%5B0%5D=1&a%5Bb%5D%5B2%5D=3',
+ // 'default => indices',
+ // );
+ expect(stringify({ a: { b: [1, 2, 3, 4], c: 'd' }, c: 'f' }, { filter: ['a', 'b', 0, 2] })).toBe(
+ 'a%5Bb%5D%5B0%5D=1&a%5Bb%5D%5B2%5D=3',
+ );
+ expect(
+ stringify(
+ { a: { b: [1, 2, 3, 4], c: 'd' }, c: 'f' },
+ { filter: ['a', 'b', 0, 2], arrayFormat: 'indices' },
+ ),
+ ).toBe('a%5Bb%5D%5B0%5D=1&a%5Bb%5D%5B2%5D=3');
+ expect(
+ stringify(
+ { a: { b: [1, 2, 3, 4], c: 'd' }, c: 'f' },
+ { filter: ['a', 'b', 0, 2], arrayFormat: 'brackets' },
+ ),
+ ).toBe('a%5Bb%5D%5B%5D=1&a%5Bb%5D%5B%5D=3');
+ });
+
+ test('supports custom representations when filter=function', function () {
+ var calls = 0;
+ var obj = { a: 'b', c: 'd', e: { f: new Date(1257894000000) } };
+ var filterFunc: StringifyOptions['filter'] = function (prefix, value) {
+ calls += 1;
+ if (calls === 1) {
+ // st.equal(prefix, '', 'prefix is empty');
+ // st.equal(value, obj);
+ expect(prefix).toBe('');
+ expect(value).toBe(obj);
+ } else if (prefix === 'c') {
+ return void 0;
+ } else if (value instanceof Date) {
+ // st.equal(prefix, 'e[f]');
+ expect(prefix).toBe('e[f]');
+ return value.getTime();
+ }
+ return value;
+ };
+
+ // st.equal(stringify(obj, { filter: filterFunc }), 'a=b&e%5Bf%5D=1257894000000');
+ // st.equal(calls, 5);
+ expect(stringify(obj, { filter: filterFunc })).toBe('a=b&e%5Bf%5D=1257894000000');
+ expect(calls).toBe(5);
+ });
+
+ test('can disable uri encoding', function () {
+ // st.equal(stringify({ a: 'b' }, { encode: false }), 'a=b');
+ // st.equal(stringify({ a: { b: 'c' } }, { encode: false }), 'a[b]=c');
+ // st.equal(
+ // stringify({ a: 'b', c: null }, { strictNullHandling: true, encode: false }),
+ // 'a=b&c',
+ // );
+ expect(stringify({ a: 'b' }, { encode: false })).toBe('a=b');
+ expect(stringify({ a: { b: 'c' } }, { encode: false })).toBe('a[b]=c');
+ expect(stringify({ a: 'b', c: null }, { strictNullHandling: true, encode: false })).toBe('a=b&c');
+ });
+
+ test('can sort the keys', function () {
+ // @ts-expect-error
+ var sort: NonNullable = function (a: string, b: string) {
+ return a.localeCompare(b);
+ };
+ // st.equal(stringify({ a: 'c', z: 'y', b: 'f' }, { sort: sort }), 'a=c&b=f&z=y');
+ // st.equal(
+ // stringify({ a: 'c', z: { j: 'a', i: 'b' }, b: 'f' }, { sort: sort }),
+ // 'a=c&b=f&z%5Bi%5D=b&z%5Bj%5D=a',
+ // );
+ expect(stringify({ a: 'c', z: 'y', b: 'f' }, { sort: sort })).toBe('a=c&b=f&z=y');
+ expect(stringify({ a: 'c', z: { j: 'a', i: 'b' }, b: 'f' }, { sort: sort })).toBe(
+ 'a=c&b=f&z%5Bi%5D=b&z%5Bj%5D=a',
+ );
+ });
+
+ test('can sort the keys at depth 3 or more too', function () {
+ // @ts-expect-error
+ var sort: NonNullable = function (a: string, b: string) {
+ return a.localeCompare(b);
+ };
+ // st.equal(
+ // stringify(
+ // { a: 'a', z: { zj: { zjb: 'zjb', zja: 'zja' }, zi: { zib: 'zib', zia: 'zia' } }, b: 'b' },
+ // { sort: sort, encode: false },
+ // ),
+ // 'a=a&b=b&z[zi][zia]=zia&z[zi][zib]=zib&z[zj][zja]=zja&z[zj][zjb]=zjb',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: 'a', z: { zj: { zjb: 'zjb', zja: 'zja' }, zi: { zib: 'zib', zia: 'zia' } }, b: 'b' },
+ // { sort: null, encode: false },
+ // ),
+ // 'a=a&z[zj][zjb]=zjb&z[zj][zja]=zja&z[zi][zib]=zib&z[zi][zia]=zia&b=b',
+ // );
+ expect(
+ stringify(
+ { a: 'a', z: { zj: { zjb: 'zjb', zja: 'zja' }, zi: { zib: 'zib', zia: 'zia' } }, b: 'b' },
+ { sort: sort, encode: false },
+ ),
+ ).toBe('a=a&b=b&z[zi][zia]=zia&z[zi][zib]=zib&z[zj][zja]=zja&z[zj][zjb]=zjb');
+ expect(
+ stringify(
+ { a: 'a', z: { zj: { zjb: 'zjb', zja: 'zja' }, zi: { zib: 'zib', zia: 'zia' } }, b: 'b' },
+ { sort: null, encode: false },
+ ),
+ ).toBe('a=a&z[zj][zjb]=zjb&z[zj][zja]=zja&z[zi][zib]=zib&z[zi][zia]=zia&b=b');
+ });
+
+ test('can stringify with custom encoding', function () {
+ // st.equal(
+ // stringify(
+ // { 県: '大阪府', '': '' },
+ // {
+ // encoder: function (str) {
+ // if (str.length === 0) {
+ // return '';
+ // }
+ // var buf = iconv.encode(str, 'shiftjis');
+ // var result = [];
+ // for (var i = 0; i < buf.length; ++i) {
+ // result.push(buf.readUInt8(i).toString(16));
+ // }
+ // return '%' + result.join('%');
+ // },
+ // },
+ // ),
+ // '%8c%a7=%91%e5%8d%e3%95%7b&=',
+ // );
+ expect(
+ stringify(
+ { 県: '大阪府', '': '' },
+ {
+ encoder: function (str) {
+ if (str.length === 0) {
+ return '';
+ }
+ var buf = iconv.encode(str, 'shiftjis');
+ var result = [];
+ for (var i = 0; i < buf.length; ++i) {
+ result.push(buf.readUInt8(i).toString(16));
+ }
+ return '%' + result.join('%');
+ },
+ },
+ ),
+ ).toBe('%8c%a7=%91%e5%8d%e3%95%7b&=');
+ });
+
+ test('receives the default encoder as a second argument', function () {
+ // stringify(
+ // { a: 1, b: new Date(), c: true, d: [1] },
+ // {
+ // encoder: function (str) {
+ // st.match(typeof str, /^(?:string|number|boolean)$/);
+ // return '';
+ // },
+ // },
+ // );
+
+ stringify(
+ { a: 1, b: new Date(), c: true, d: [1] },
+ {
+ encoder: function (str) {
+ // st.match(typeof str, /^(?:string|number|boolean)$/);
+ assert.match(typeof str, /^(?:string|number|boolean)$/);
+ return '';
+ },
+ },
+ );
+ });
+
+ test('receives the default encoder as a second argument', function () {
+ // stringify(
+ // { a: 1 },
+ // {
+ // encoder: function (str, defaultEncoder) {
+ // st.equal(defaultEncoder, utils.encode);
+ // },
+ // },
+ // );
+
+ stringify(
+ { a: 1 },
+ {
+ // @ts-ignore
+ encoder: function (_str, defaultEncoder) {
+ expect(defaultEncoder).toBe(encode);
+ },
+ },
+ );
+ });
+
+ test('throws error with wrong encoder', function () {
+ // st['throws'](function () {
+ // stringify({}, { encoder: 'string' });
+ // }, new TypeError('Encoder has to be a function.'));
+ // st.end();
+ expect(() => {
+ // @ts-expect-error
+ stringify({}, { encoder: 'string' });
+ }).toThrow(TypeError);
+ });
+
+ (typeof Buffer === 'undefined' ? test.skip : test)(
+ 'can use custom encoder for a buffer object',
+ function () {
+ // st.equal(
+ // stringify(
+ // { a: Buffer.from([1]) },
+ // {
+ // encoder: function (buffer) {
+ // if (typeof buffer === 'string') {
+ // return buffer;
+ // }
+ // return String.fromCharCode(buffer.readUInt8(0) + 97);
+ // },
+ // },
+ // ),
+ // 'a=b',
+ // );
+ expect(
+ stringify(
+ { a: Buffer.from([1]) },
+ {
+ encoder: function (buffer) {
+ if (typeof buffer === 'string') {
+ return buffer;
+ }
+ return String.fromCharCode(buffer.readUInt8(0) + 97);
+ },
+ },
+ ),
+ ).toBe('a=b');
+
+ // st.equal(
+ // stringify(
+ // { a: Buffer.from('a b') },
+ // {
+ // encoder: function (buffer) {
+ // return buffer;
+ // },
+ // },
+ // ),
+ // 'a=a b',
+ // );
+ expect(
+ stringify(
+ { a: Buffer.from('a b') },
+ {
+ encoder: function (buffer) {
+ return buffer;
+ },
+ },
+ ),
+ ).toBe('a=a b');
+ },
+ );
+
+ test('serializeDate option', function () {
+ var date = new Date();
+ // st.equal(
+ // stringify({ a: date }),
+ // 'a=' + date.toISOString().replace(/:/g, '%3A'),
+ // 'default is toISOString',
+ // );
+ expect(stringify({ a: date })).toBe('a=' + date.toISOString().replace(/:/g, '%3A'));
+
+ var mutatedDate = new Date();
+ mutatedDate.toISOString = function () {
+ throw new SyntaxError();
+ };
+ // st['throws'](function () {
+ // mutatedDate.toISOString();
+ // }, SyntaxError);
+ expect(() => {
+ mutatedDate.toISOString();
+ }).toThrow(SyntaxError);
+ // st.equal(
+ // stringify({ a: mutatedDate }),
+ // 'a=' + Date.prototype.toISOString.call(mutatedDate).replace(/:/g, '%3A'),
+ // 'toISOString works even when method is not locally present',
+ // );
+ expect(stringify({ a: mutatedDate })).toBe(
+ 'a=' + Date.prototype.toISOString.call(mutatedDate).replace(/:/g, '%3A'),
+ );
+
+ var specificDate = new Date(6);
+ // st.equal(
+ // stringify(
+ // { a: specificDate },
+ // {
+ // serializeDate: function (d) {
+ // return d.getTime() * 7;
+ // },
+ // },
+ // ),
+ // 'a=42',
+ // 'custom serializeDate function called',
+ // );
+ expect(
+ stringify(
+ { a: specificDate },
+ {
+ // @ts-ignore
+ serializeDate: function (d) {
+ return d.getTime() * 7;
+ },
+ },
+ ),
+ ).toBe('a=42');
+
+ // st.equal(
+ // stringify(
+ // { a: [date] },
+ // {
+ // serializeDate: function (d) {
+ // return d.getTime();
+ // },
+ // arrayFormat: 'comma',
+ // },
+ // ),
+ // 'a=' + date.getTime(),
+ // 'works with arrayFormat comma',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [date] },
+ // {
+ // serializeDate: function (d) {
+ // return d.getTime();
+ // },
+ // arrayFormat: 'comma',
+ // commaRoundTrip: true,
+ // },
+ // ),
+ // 'a%5B%5D=' + date.getTime(),
+ // 'works with arrayFormat comma',
+ // );
+ expect(
+ stringify(
+ { a: [date] },
+ {
+ // @ts-expect-error
+ serializeDate: function (d) {
+ return d.getTime();
+ },
+ arrayFormat: 'comma',
+ },
+ ),
+ ).toBe('a=' + date.getTime());
+ expect(
+ stringify(
+ { a: [date] },
+ {
+ // @ts-expect-error
+ serializeDate: function (d) {
+ return d.getTime();
+ },
+ arrayFormat: 'comma',
+ commaRoundTrip: true,
+ },
+ ),
+ ).toBe('a%5B%5D=' + date.getTime());
+ });
+
+ test('RFC 1738 serialization', function () {
+ // st.equal(stringify({ a: 'b c' }, { format: formats.RFC1738 }), 'a=b+c');
+ // st.equal(stringify({ 'a b': 'c d' }, { format: formats.RFC1738 }), 'a+b=c+d');
+ // st.equal(
+ // stringify({ 'a b': Buffer.from('a b') }, { format: formats.RFC1738 }),
+ // 'a+b=a+b',
+ // );
+ expect(stringify({ a: 'b c' }, { format: 'RFC1738' })).toBe('a=b+c');
+ expect(stringify({ 'a b': 'c d' }, { format: 'RFC1738' })).toBe('a+b=c+d');
+ expect(stringify({ 'a b': Buffer.from('a b') }, { format: 'RFC1738' })).toBe('a+b=a+b');
+
+ // st.equal(stringify({ 'foo(ref)': 'bar' }, { format: formats.RFC1738 }), 'foo(ref)=bar');
+ expect(stringify({ 'foo(ref)': 'bar' }, { format: 'RFC1738' })).toBe('foo(ref)=bar');
+ });
+
+ test('RFC 3986 spaces serialization', function () {
+ // st.equal(stringify({ a: 'b c' }, { format: formats.RFC3986 }), 'a=b%20c');
+ // st.equal(stringify({ 'a b': 'c d' }, { format: formats.RFC3986 }), 'a%20b=c%20d');
+ // st.equal(
+ // stringify({ 'a b': Buffer.from('a b') }, { format: formats.RFC3986 }),
+ // 'a%20b=a%20b',
+ // );
+ expect(stringify({ a: 'b c' }, { format: 'RFC3986' })).toBe('a=b%20c');
+ expect(stringify({ 'a b': 'c d' }, { format: 'RFC3986' })).toBe('a%20b=c%20d');
+ expect(stringify({ 'a b': Buffer.from('a b') }, { format: 'RFC3986' })).toBe('a%20b=a%20b');
+ });
+
+ test('Backward compatibility to RFC 3986', function () {
+ // st.equal(stringify({ a: 'b c' }), 'a=b%20c');
+ // st.equal(stringify({ 'a b': Buffer.from('a b') }), 'a%20b=a%20b');
+ expect(stringify({ a: 'b c' })).toBe('a=b%20c');
+ expect(stringify({ 'a b': Buffer.from('a b') })).toBe('a%20b=a%20b');
+ });
+
+ test('Edge cases and unknown formats', function () {
+ ['UFO1234', false, 1234, null, {}, []].forEach(function (format) {
+ // st['throws'](function () {
+ // stringify({ a: 'b c' }, { format: format });
+ // }, new TypeError('Unknown format option provided.'));
+ expect(() => {
+ // @ts-expect-error
+ stringify({ a: 'b c' }, { format: format });
+ }).toThrow(TypeError);
+ });
+ });
+
+ test('encodeValuesOnly', function () {
+ // st.equal(
+ // stringify(
+ // { a: 'b', c: ['d', 'e=f'], f: [['g'], ['h']] },
+ // { encodeValuesOnly: true, arrayFormat: 'indices' },
+ // ),
+ // 'a=b&c[0]=d&c[1]=e%3Df&f[0][0]=g&f[1][0]=h',
+ // 'encodeValuesOnly + indices',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: 'b', c: ['d', 'e=f'], f: [['g'], ['h']] },
+ // { encodeValuesOnly: true, arrayFormat: 'brackets' },
+ // ),
+ // 'a=b&c[]=d&c[]=e%3Df&f[][]=g&f[][]=h',
+ // 'encodeValuesOnly + brackets',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: 'b', c: ['d', 'e=f'], f: [['g'], ['h']] },
+ // { encodeValuesOnly: true, arrayFormat: 'repeat' },
+ // ),
+ // 'a=b&c=d&c=e%3Df&f=g&f=h',
+ // 'encodeValuesOnly + repeat',
+ // );
+ expect(
+ stringify(
+ { a: 'b', c: ['d', 'e=f'], f: [['g'], ['h']] },
+ { encodeValuesOnly: true, arrayFormat: 'indices' },
+ ),
+ ).toBe('a=b&c[0]=d&c[1]=e%3Df&f[0][0]=g&f[1][0]=h');
+ expect(
+ stringify(
+ { a: 'b', c: ['d', 'e=f'], f: [['g'], ['h']] },
+ { encodeValuesOnly: true, arrayFormat: 'brackets' },
+ ),
+ ).toBe('a=b&c[]=d&c[]=e%3Df&f[][]=g&f[][]=h');
+ expect(
+ stringify(
+ { a: 'b', c: ['d', 'e=f'], f: [['g'], ['h']] },
+ { encodeValuesOnly: true, arrayFormat: 'repeat' },
+ ),
+ ).toBe('a=b&c=d&c=e%3Df&f=g&f=h');
+
+ // st.equal(
+ // stringify({ a: 'b', c: ['d', 'e'], f: [['g'], ['h']] }, { arrayFormat: 'indices' }),
+ // 'a=b&c%5B0%5D=d&c%5B1%5D=e&f%5B0%5D%5B0%5D=g&f%5B1%5D%5B0%5D=h',
+ // 'no encodeValuesOnly + indices',
+ // );
+ // st.equal(
+ // stringify({ a: 'b', c: ['d', 'e'], f: [['g'], ['h']] }, { arrayFormat: 'brackets' }),
+ // 'a=b&c%5B%5D=d&c%5B%5D=e&f%5B%5D%5B%5D=g&f%5B%5D%5B%5D=h',
+ // 'no encodeValuesOnly + brackets',
+ // );
+ // st.equal(
+ // stringify({ a: 'b', c: ['d', 'e'], f: [['g'], ['h']] }, { arrayFormat: 'repeat' }),
+ // 'a=b&c=d&c=e&f=g&f=h',
+ // 'no encodeValuesOnly + repeat',
+ // );
+ expect(stringify({ a: 'b', c: ['d', 'e'], f: [['g'], ['h']] }, { arrayFormat: 'indices' })).toBe(
+ 'a=b&c%5B0%5D=d&c%5B1%5D=e&f%5B0%5D%5B0%5D=g&f%5B1%5D%5B0%5D=h',
+ );
+ expect(stringify({ a: 'b', c: ['d', 'e'], f: [['g'], ['h']] }, { arrayFormat: 'brackets' })).toBe(
+ 'a=b&c%5B%5D=d&c%5B%5D=e&f%5B%5D%5B%5D=g&f%5B%5D%5B%5D=h',
+ );
+ expect(stringify({ a: 'b', c: ['d', 'e'], f: [['g'], ['h']] }, { arrayFormat: 'repeat' })).toBe(
+ 'a=b&c=d&c=e&f=g&f=h',
+ );
+ });
+
+ test('encodeValuesOnly - strictNullHandling', function () {
+ // st.equal(
+ // stringify({ a: { b: null } }, { encodeValuesOnly: true, strictNullHandling: true }),
+ // 'a[b]',
+ // );
+ expect(stringify({ a: { b: null } }, { encodeValuesOnly: true, strictNullHandling: true })).toBe('a[b]');
+ });
+
+ test('throws if an invalid charset is specified', function () {
+ // st['throws'](function () {
+ // stringify({ a: 'b' }, { charset: 'foobar' });
+ // }, new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined'));
+ expect(() => {
+ // @ts-expect-error
+ stringify({ a: 'b' }, { charset: 'foobar' });
+ }).toThrow(TypeError);
+ });
+
+ test('respects a charset of iso-8859-1', function () {
+ // st.equal(stringify({ æ: 'æ' }, { charset: 'iso-8859-1' }), '%E6=%E6');
+ expect(stringify({ æ: 'æ' }, { charset: 'iso-8859-1' })).toBe('%E6=%E6');
+ });
+
+ test('encodes unrepresentable chars as numeric entities in iso-8859-1 mode', function () {
+ // st.equal(stringify({ a: '☺' }, { charset: 'iso-8859-1' }), 'a=%26%239786%3B');
+ expect(stringify({ a: '☺' }, { charset: 'iso-8859-1' })).toBe('a=%26%239786%3B');
+ });
+
+ test('respects an explicit charset of utf-8 (the default)', function () {
+ // st.equal(stringify({ a: 'æ' }, { charset: 'utf-8' }), 'a=%C3%A6');
+ expect(stringify({ a: 'æ' }, { charset: 'utf-8' })).toBe('a=%C3%A6');
+ });
+
+ test('`charsetSentinel` option', function () {
+ // st.equal(
+ // stringify({ a: 'æ' }, { charsetSentinel: true, charset: 'utf-8' }),
+ // 'utf8=%E2%9C%93&a=%C3%A6',
+ // 'adds the right sentinel when instructed to and the charset is utf-8',
+ // );
+ expect(stringify({ a: 'æ' }, { charsetSentinel: true, charset: 'utf-8' })).toBe(
+ 'utf8=%E2%9C%93&a=%C3%A6',
+ );
+
+ // st.equal(
+ // stringify({ a: 'æ' }, { charsetSentinel: true, charset: 'iso-8859-1' }),
+ // 'utf8=%26%2310003%3B&a=%E6',
+ // 'adds the right sentinel when instructed to and the charset is iso-8859-1',
+ // );
+ expect(stringify({ a: 'æ' }, { charsetSentinel: true, charset: 'iso-8859-1' })).toBe(
+ 'utf8=%26%2310003%3B&a=%E6',
+ );
+ });
+
+ test('does not mutate the options argument', function () {
+ var options = {};
+ stringify({}, options);
+ // st.deepEqual(options, {});
+ expect(options).toEqual({});
+ });
+
+ test('strictNullHandling works with custom filter', function () {
+ // @ts-expect-error
+ var filter = function (_prefix, value) {
+ return value;
+ };
+
+ var options = { strictNullHandling: true, filter: filter };
+ // st.equal(stringify({ key: null }, options), 'key');
+ expect(stringify({ key: null }, options)).toBe('key');
+ });
+
+ test('strictNullHandling works with null serializeDate', function () {
+ var serializeDate = function () {
+ return null;
+ };
+ var options = { strictNullHandling: true, serializeDate: serializeDate };
+ var date = new Date();
+ // st.equal(stringify({ key: date }, options), 'key');
+ // @ts-expect-error
+ expect(stringify({ key: date }, options)).toBe('key');
+ });
+
+ test('allows for encoding keys and values differently', function () {
+ // @ts-expect-error
+ var encoder = function (str, defaultEncoder, charset, type) {
+ if (type === 'key') {
+ return defaultEncoder(str, defaultEncoder, charset, type).toLowerCase();
+ }
+ if (type === 'value') {
+ return defaultEncoder(str, defaultEncoder, charset, type).toUpperCase();
+ }
+ throw 'this should never happen! type: ' + type;
+ };
+
+ // st.deepEqual(stringify({ KeY: 'vAlUe' }, { encoder: encoder }), 'key=VALUE');
+ expect(stringify({ KeY: 'vAlUe' }, { encoder: encoder })).toBe('key=VALUE');
+ });
+
+ test('objects inside arrays', function () {
+ var obj = { a: { b: { c: 'd', e: 'f' } } };
+ var withArray = { a: { b: [{ c: 'd', e: 'f' }] } };
+
+ // st.equal(
+ // stringify(obj, { encode: false }),
+ // 'a[b][c]=d&a[b][e]=f',
+ // 'no array, no arrayFormat',
+ // );
+ // st.equal(
+ // stringify(obj, { encode: false, arrayFormat: 'brackets' }),
+ // 'a[b][c]=d&a[b][e]=f',
+ // 'no array, bracket',
+ // );
+ // st.equal(
+ // stringify(obj, { encode: false, arrayFormat: 'indices' }),
+ // 'a[b][c]=d&a[b][e]=f',
+ // 'no array, indices',
+ // );
+ // st.equal(
+ // stringify(obj, { encode: false, arrayFormat: 'repeat' }),
+ // 'a[b][c]=d&a[b][e]=f',
+ // 'no array, repeat',
+ // );
+ // st.equal(
+ // stringify(obj, { encode: false, arrayFormat: 'comma' }),
+ // 'a[b][c]=d&a[b][e]=f',
+ // 'no array, comma',
+ // );
+ expect(stringify(obj, { encode: false })).toBe('a[b][c]=d&a[b][e]=f');
+ expect(stringify(obj, { encode: false, arrayFormat: 'brackets' })).toBe('a[b][c]=d&a[b][e]=f');
+ expect(stringify(obj, { encode: false, arrayFormat: 'indices' })).toBe('a[b][c]=d&a[b][e]=f');
+ expect(stringify(obj, { encode: false, arrayFormat: 'repeat' })).toBe('a[b][c]=d&a[b][e]=f');
+ expect(stringify(obj, { encode: false, arrayFormat: 'comma' })).toBe('a[b][c]=d&a[b][e]=f');
+
+ // st.equal(
+ // stringify(withArray, { encode: false }),
+ // 'a[b][0][c]=d&a[b][0][e]=f',
+ // 'array, no arrayFormat',
+ // );
+ // st.equal(
+ // stringify(withArray, { encode: false, arrayFormat: 'brackets' }),
+ // 'a[b][][c]=d&a[b][][e]=f',
+ // 'array, bracket',
+ // );
+ // st.equal(
+ // stringify(withArray, { encode: false, arrayFormat: 'indices' }),
+ // 'a[b][0][c]=d&a[b][0][e]=f',
+ // 'array, indices',
+ // );
+ // st.equal(
+ // stringify(withArray, { encode: false, arrayFormat: 'repeat' }),
+ // 'a[b][c]=d&a[b][e]=f',
+ // 'array, repeat',
+ // );
+ // st.equal(
+ // stringify(withArray, { encode: false, arrayFormat: 'comma' }),
+ // '???',
+ // 'array, comma',
+ // { skip: 'TODO: figure out what this should do' },
+ // );
+ expect(stringify(withArray, { encode: false })).toBe('a[b][0][c]=d&a[b][0][e]=f');
+ expect(stringify(withArray, { encode: false, arrayFormat: 'brackets' })).toBe('a[b][][c]=d&a[b][][e]=f');
+ expect(stringify(withArray, { encode: false, arrayFormat: 'indices' })).toBe('a[b][0][c]=d&a[b][0][e]=f');
+ expect(stringify(withArray, { encode: false, arrayFormat: 'repeat' })).toBe('a[b][c]=d&a[b][e]=f');
+ // !TODo: Figure out what this should do
+ // expect(stringify(withArray, { encode: false, arrayFormat: 'comma' })).toBe(
+ // 'a[b][c]=d&a[b][e]=f',
+ // );
+ });
+
+ test('stringifies sparse arrays', function () {
+ // st.equal(
+ // stringify({ a: [, '2', , , '1'] }, { encodeValuesOnly: true, arrayFormat: 'indices' }),
+ // 'a[1]=2&a[4]=1',
+ // );
+ // st.equal(
+ // stringify({ a: [, '2', , , '1'] }, { encodeValuesOnly: true, arrayFormat: 'brackets' }),
+ // 'a[]=2&a[]=1',
+ // );
+ // st.equal(
+ // stringify({ a: [, '2', , , '1'] }, { encodeValuesOnly: true, arrayFormat: 'repeat' }),
+ // 'a=2&a=1',
+ // );
+ expect(stringify({ a: [, '2', , , '1'] }, { encodeValuesOnly: true, arrayFormat: 'indices' })).toBe(
+ 'a[1]=2&a[4]=1',
+ );
+ expect(stringify({ a: [, '2', , , '1'] }, { encodeValuesOnly: true, arrayFormat: 'brackets' })).toBe(
+ 'a[]=2&a[]=1',
+ );
+ expect(stringify({ a: [, '2', , , '1'] }, { encodeValuesOnly: true, arrayFormat: 'repeat' })).toBe(
+ 'a=2&a=1',
+ );
+
+ // st.equal(
+ // stringify(
+ // { a: [, { b: [, , { c: '1' }] }] },
+ // { encodeValuesOnly: true, arrayFormat: 'indices' },
+ // ),
+ // 'a[1][b][2][c]=1',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [, { b: [, , { c: '1' }] }] },
+ // { encodeValuesOnly: true, arrayFormat: 'brackets' },
+ // ),
+ // 'a[][b][][c]=1',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [, { b: [, , { c: '1' }] }] },
+ // { encodeValuesOnly: true, arrayFormat: 'repeat' },
+ // ),
+ // 'a[b][c]=1',
+ // );
+ expect(
+ stringify({ a: [, { b: [, , { c: '1' }] }] }, { encodeValuesOnly: true, arrayFormat: 'indices' }),
+ ).toBe('a[1][b][2][c]=1');
+ expect(
+ stringify({ a: [, { b: [, , { c: '1' }] }] }, { encodeValuesOnly: true, arrayFormat: 'brackets' }),
+ ).toBe('a[][b][][c]=1');
+ expect(
+ stringify({ a: [, { b: [, , { c: '1' }] }] }, { encodeValuesOnly: true, arrayFormat: 'repeat' }),
+ ).toBe('a[b][c]=1');
+
+ // st.equal(
+ // stringify(
+ // { a: [, [, , [, , , { c: '1' }]]] },
+ // { encodeValuesOnly: true, arrayFormat: 'indices' },
+ // ),
+ // 'a[1][2][3][c]=1',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [, [, , [, , , { c: '1' }]]] },
+ // { encodeValuesOnly: true, arrayFormat: 'brackets' },
+ // ),
+ // 'a[][][][c]=1',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [, [, , [, , , { c: '1' }]]] },
+ // { encodeValuesOnly: true, arrayFormat: 'repeat' },
+ // ),
+ // 'a[c]=1',
+ // );
+ expect(
+ stringify({ a: [, [, , [, , , { c: '1' }]]] }, { encodeValuesOnly: true, arrayFormat: 'indices' }),
+ ).toBe('a[1][2][3][c]=1');
+ expect(
+ stringify({ a: [, [, , [, , , { c: '1' }]]] }, { encodeValuesOnly: true, arrayFormat: 'brackets' }),
+ ).toBe('a[][][][c]=1');
+ expect(
+ stringify({ a: [, [, , [, , , { c: '1' }]]] }, { encodeValuesOnly: true, arrayFormat: 'repeat' }),
+ ).toBe('a[c]=1');
+
+ // st.equal(
+ // stringify(
+ // { a: [, [, , [, , , { c: [, '1'] }]]] },
+ // { encodeValuesOnly: true, arrayFormat: 'indices' },
+ // ),
+ // 'a[1][2][3][c][1]=1',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [, [, , [, , , { c: [, '1'] }]]] },
+ // { encodeValuesOnly: true, arrayFormat: 'brackets' },
+ // ),
+ // 'a[][][][c][]=1',
+ // );
+ // st.equal(
+ // stringify(
+ // { a: [, [, , [, , , { c: [, '1'] }]]] },
+ // { encodeValuesOnly: true, arrayFormat: 'repeat' },
+ // ),
+ // 'a[c]=1',
+ // );
+ expect(
+ stringify({ a: [, [, , [, , , { c: [, '1'] }]]] }, { encodeValuesOnly: true, arrayFormat: 'indices' }),
+ ).toBe('a[1][2][3][c][1]=1');
+ expect(
+ stringify({ a: [, [, , [, , , { c: [, '1'] }]]] }, { encodeValuesOnly: true, arrayFormat: 'brackets' }),
+ ).toBe('a[][][][c][]=1');
+ expect(
+ stringify({ a: [, [, , [, , , { c: [, '1'] }]]] }, { encodeValuesOnly: true, arrayFormat: 'repeat' }),
+ ).toBe('a[c]=1');
+ });
+
+ test('encodes a very long string', function () {
+ var chars = [];
+ var expected = [];
+ for (var i = 0; i < 5e3; i++) {
+ chars.push(' ' + i);
+
+ expected.push('%20' + i);
+ }
+
+ var obj = {
+ foo: chars.join(''),
+ };
+
+ // st.equal(
+ // stringify(obj, { arrayFormat: 'bracket', charset: 'utf-8' }),
+ // 'foo=' + expected.join(''),
+ // );
+ // @ts-expect-error
+ expect(stringify(obj, { arrayFormat: 'bracket', charset: 'utf-8' })).toBe('foo=' + expected.join(''));
+ });
+});
+
+describe('stringifies empty keys', function () {
+ empty_test_cases.forEach(function (testCase) {
+ test('stringifies an object with empty string key with ' + testCase.input, function () {
+ // st.deepEqual(
+ // stringify(testCase.withEmptyKeys, { encode: false, arrayFormat: 'indices' }),
+ // testCase.stringifyOutput.indices,
+ // 'test case: ' + testCase.input + ', indices',
+ // );
+ // st.deepEqual(
+ // stringify(testCase.withEmptyKeys, { encode: false, arrayFormat: 'brackets' }),
+ // testCase.stringifyOutput.brackets,
+ // 'test case: ' + testCase.input + ', brackets',
+ // );
+ // st.deepEqual(
+ // stringify(testCase.withEmptyKeys, { encode: false, arrayFormat: 'repeat' }),
+ // testCase.stringifyOutput.repeat,
+ // 'test case: ' + testCase.input + ', repeat',
+ // );
+ expect(stringify(testCase.with_empty_keys, { encode: false, arrayFormat: 'indices' })).toBe(
+ testCase.stringify_output.indices,
+ );
+ expect(stringify(testCase.with_empty_keys, { encode: false, arrayFormat: 'brackets' })).toBe(
+ testCase.stringify_output.brackets,
+ );
+ expect(stringify(testCase.with_empty_keys, { encode: false, arrayFormat: 'repeat' })).toBe(
+ testCase.stringify_output.repeat,
+ );
+ });
+ });
+
+ test('edge case with object/arrays', function () {
+ // st.deepEqual(stringify({ '': { '': [2, 3] } }, { encode: false }), '[][0]=2&[][1]=3');
+ // st.deepEqual(
+ // stringify({ '': { '': [2, 3], a: 2 } }, { encode: false }),
+ // '[][0]=2&[][1]=3&[a]=2',
+ // );
+ // st.deepEqual(
+ // stringify({ '': { '': [2, 3] } }, { encode: false, arrayFormat: 'indices' }),
+ // '[][0]=2&[][1]=3',
+ // );
+ // st.deepEqual(
+ // stringify({ '': { '': [2, 3], a: 2 } }, { encode: false, arrayFormat: 'indices' }),
+ // '[][0]=2&[][1]=3&[a]=2',
+ // );
+ expect(stringify({ '': { '': [2, 3] } }, { encode: false })).toBe('[][0]=2&[][1]=3');
+ expect(stringify({ '': { '': [2, 3], a: 2 } }, { encode: false })).toBe('[][0]=2&[][1]=3&[a]=2');
+ expect(stringify({ '': { '': [2, 3] } }, { encode: false, arrayFormat: 'indices' })).toBe(
+ '[][0]=2&[][1]=3',
+ );
+ expect(stringify({ '': { '': [2, 3], a: 2 } }, { encode: false, arrayFormat: 'indices' })).toBe(
+ '[][0]=2&[][1]=3&[a]=2',
+ );
+ });
+});
diff --git a/tests/qs/utils.test.ts b/tests/qs/utils.test.ts
new file mode 100644
index 00000000..a58af961
--- /dev/null
+++ b/tests/qs/utils.test.ts
@@ -0,0 +1,169 @@
+import { combine, merge, is_buffer, assign_single_source } from 'stainless-v0/internal/qs/utils';
+
+describe('merge()', function () {
+ // t.deepEqual(merge(null, true), [null, true], 'merges true into null');
+ expect(merge(null, true)).toEqual([null, true]);
+
+ // t.deepEqual(merge(null, [42]), [null, 42], 'merges null into an array');
+ expect(merge(null, [42])).toEqual([null, 42]);
+
+ // t.deepEqual(
+ // merge({ a: 'b' }, { a: 'c' }),
+ // { a: ['b', 'c'] },
+ // 'merges two objects with the same key',
+ // );
+ expect(merge({ a: 'b' }, { a: 'c' })).toEqual({ a: ['b', 'c'] });
+
+ var oneMerged = merge({ foo: 'bar' }, { foo: { first: '123' } });
+ // t.deepEqual(
+ // oneMerged,
+ // { foo: ['bar', { first: '123' }] },
+ // 'merges a standalone and an object into an array',
+ // );
+ expect(oneMerged).toEqual({ foo: ['bar', { first: '123' }] });
+
+ var twoMerged = merge({ foo: ['bar', { first: '123' }] }, { foo: { second: '456' } });
+ // t.deepEqual(
+ // twoMerged,
+ // { foo: { 0: 'bar', 1: { first: '123' }, second: '456' } },
+ // 'merges a standalone and two objects into an array',
+ // );
+ expect(twoMerged).toEqual({ foo: { 0: 'bar', 1: { first: '123' }, second: '456' } });
+
+ var sandwiched = merge({ foo: ['bar', { first: '123', second: '456' }] }, { foo: 'baz' });
+ // t.deepEqual(
+ // sandwiched,
+ // { foo: ['bar', { first: '123', second: '456' }, 'baz'] },
+ // 'merges an object sandwiched by two standalones into an array',
+ // );
+ expect(sandwiched).toEqual({ foo: ['bar', { first: '123', second: '456' }, 'baz'] });
+
+ var nestedArrays = merge({ foo: ['baz'] }, { foo: ['bar', 'xyzzy'] });
+ // t.deepEqual(nestedArrays, { foo: ['baz', 'bar', 'xyzzy'] });
+ expect(nestedArrays).toEqual({ foo: ['baz', 'bar', 'xyzzy'] });
+
+ var noOptionsNonObjectSource = merge({ foo: 'baz' }, 'bar');
+ // t.deepEqual(noOptionsNonObjectSource, { foo: 'baz', bar: true });
+ expect(noOptionsNonObjectSource).toEqual({ foo: 'baz', bar: true });
+
+ (typeof Object.defineProperty !== 'function' ? test.skip : test)(
+ 'avoids invoking array setters unnecessarily',
+ function () {
+ var setCount = 0;
+ var getCount = 0;
+ var observed: any[] = [];
+ Object.defineProperty(observed, 0, {
+ get: function () {
+ getCount += 1;
+ return { bar: 'baz' };
+ },
+ set: function () {
+ setCount += 1;
+ },
+ });
+ merge(observed, [null]);
+ // st.equal(setCount, 0);
+ // st.equal(getCount, 1);
+ expect(setCount).toEqual(0);
+ expect(getCount).toEqual(1);
+ observed[0] = observed[0];
+ // st.equal(setCount, 1);
+ // st.equal(getCount, 2);
+ expect(setCount).toEqual(1);
+ expect(getCount).toEqual(2);
+ },
+ );
+});
+
+test('assign()', function () {
+ var target = { a: 1, b: 2 };
+ var source = { b: 3, c: 4 };
+ var result = assign_single_source(target, source);
+
+ expect(result).toEqual(target);
+ expect(target).toEqual({ a: 1, b: 3, c: 4 });
+ expect(source).toEqual({ b: 3, c: 4 });
+});
+
+describe('combine()', function () {
+ test('both arrays', function () {
+ var a = [1];
+ var b = [2];
+ var combined = combine(a, b);
+
+ // st.deepEqual(a, [1], 'a is not mutated');
+ // st.deepEqual(b, [2], 'b is not mutated');
+ // st.notEqual(a, combined, 'a !== combined');
+ // st.notEqual(b, combined, 'b !== combined');
+ // st.deepEqual(combined, [1, 2], 'combined is a + b');
+ expect(a).toEqual([1]);
+ expect(b).toEqual([2]);
+ expect(combined).toEqual([1, 2]);
+ expect(a).not.toEqual(combined);
+ expect(b).not.toEqual(combined);
+ });
+
+ test('one array, one non-array', function () {
+ var aN = 1;
+ var a = [aN];
+ var bN = 2;
+ var b = [bN];
+
+ var combinedAnB = combine(aN, b);
+ // st.deepEqual(b, [bN], 'b is not mutated');
+ // st.notEqual(aN, combinedAnB, 'aN + b !== aN');
+ // st.notEqual(a, combinedAnB, 'aN + b !== a');
+ // st.notEqual(bN, combinedAnB, 'aN + b !== bN');
+ // st.notEqual(b, combinedAnB, 'aN + b !== b');
+ // st.deepEqual([1, 2], combinedAnB, 'first argument is array-wrapped when not an array');
+ expect(b).toEqual([bN]);
+ expect(combinedAnB).not.toEqual(aN);
+ expect(combinedAnB).not.toEqual(a);
+ expect(combinedAnB).not.toEqual(bN);
+ expect(combinedAnB).not.toEqual(b);
+ expect(combinedAnB).toEqual([1, 2]);
+
+ var combinedABn = combine(a, bN);
+ // st.deepEqual(a, [aN], 'a is not mutated');
+ // st.notEqual(aN, combinedABn, 'a + bN !== aN');
+ // st.notEqual(a, combinedABn, 'a + bN !== a');
+ // st.notEqual(bN, combinedABn, 'a + bN !== bN');
+ // st.notEqual(b, combinedABn, 'a + bN !== b');
+ // st.deepEqual([1, 2], combinedABn, 'second argument is array-wrapped when not an array');
+ expect(a).toEqual([aN]);
+ expect(combinedABn).not.toEqual(aN);
+ expect(combinedABn).not.toEqual(a);
+ expect(combinedABn).not.toEqual(bN);
+ expect(combinedABn).not.toEqual(b);
+ expect(combinedABn).toEqual([1, 2]);
+ });
+
+ test('neither is an array', function () {
+ var combined = combine(1, 2);
+ // st.notEqual(1, combined, '1 + 2 !== 1');
+ // st.notEqual(2, combined, '1 + 2 !== 2');
+ // st.deepEqual([1, 2], combined, 'both arguments are array-wrapped when not an array');
+ expect(combined).not.toEqual(1);
+ expect(combined).not.toEqual(2);
+ expect(combined).toEqual([1, 2]);
+ });
+});
+
+test('is_buffer()', function () {
+ for (const x of [null, undefined, true, false, '', 'abc', 42, 0, NaN, {}, [], function () {}, /a/g]) {
+ // t.equal(is_buffer(x), false, inspect(x) + ' is not a buffer');
+ expect(is_buffer(x)).toEqual(false);
+ }
+
+ var fakeBuffer = { constructor: Buffer };
+ // t.equal(is_buffer(fakeBuffer), false, 'fake buffer is not a buffer');
+ expect(is_buffer(fakeBuffer)).toEqual(false);
+
+ var saferBuffer = Buffer.from('abc');
+ // t.equal(is_buffer(saferBuffer), true, 'SaferBuffer instance is a buffer');
+ expect(is_buffer(saferBuffer)).toEqual(true);
+
+ var buffer = Buffer.from('abc');
+ // t.equal(is_buffer(buffer), true, 'real Buffer instance is a buffer');
+ expect(is_buffer(buffer)).toEqual(true);
+});
diff --git a/tests/stringifyQuery.test.ts b/tests/stringifyQuery.test.ts
index 4b7d950e..8e4694fb 100644
--- a/tests/stringifyQuery.test.ts
+++ b/tests/stringifyQuery.test.ts
@@ -20,10 +20,4 @@ describe(stringifyQuery, () => {
expect(stringifyQuery(input)).toEqual(expected);
});
}
-
- for (const value of [[], {}, new Date()]) {
- it(`${JSON.stringify(value)} -> `, () => {
- expect(() => stringifyQuery({ value })).toThrow(`Cannot stringify type ${typeof value}`);
- });
- }
});
diff --git a/tsc-multi.json b/tsc-multi.json
index 4facad5a..170bac7a 100644
--- a/tsc-multi.json
+++ b/tsc-multi.json
@@ -1,7 +1,7 @@
{
"targets": [
- { "extname": ".js", "module": "commonjs" },
- { "extname": ".mjs", "module": "esnext" }
+ { "extname": ".js", "module": "commonjs", "shareHelpers": "internal/tslib.js" },
+ { "extname": ".mjs", "module": "esnext", "shareHelpers": "internal/tslib.mjs" }
],
"projects": ["tsconfig.build.json"]
}
diff --git a/tsconfig.build.json b/tsconfig.build.json
index a199e5ca..0b3f7cda 100644
--- a/tsconfig.build.json
+++ b/tsconfig.build.json
@@ -6,7 +6,7 @@
"rootDir": "./dist/src",
"paths": {
"stainless-v0/*": ["dist/src/*"],
- "stainless-v0": ["dist/src/index.ts"],
+ "stainless-v0": ["dist/src/index.ts"]
},
"noEmit": false,
"declaration": true,
diff --git a/tsconfig.json b/tsconfig.json
index d4be0f12..e57aeda8 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -31,7 +31,7 @@
"noUncheckedIndexedAccess": true,
"noImplicitOverride": true,
"noPropertyAccessFromIndexSignature": true,
- "isolatedModules": false,
+ "isolatedModules": false,
"skipLibCheck": true
}
diff --git a/yarn.lock b/yarn.lock
index b40f3dc3..43da555d 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -961,62 +961,62 @@
dependencies:
"@types/yargs-parser" "*"
-"@typescript-eslint/eslint-plugin@8.24.0", "@typescript-eslint/eslint-plugin@^8.24.0":
- version "8.24.0"
- resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.24.0.tgz#574a95d67660a1e4544ae131d672867a5b40abb3"
- integrity sha512-aFcXEJJCI4gUdXgoo/j9udUYIHgF23MFkg09LFz2dzEmU0+1Plk4rQWv/IYKvPHAtlkkGoB3m5e6oUp+JPsNaQ==
+"@typescript-eslint/eslint-plugin@8.31.1":
+ version "8.31.1"
+ resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.31.1.tgz#62f1befe59647524994e89de4516d8dcba7a850a"
+ integrity sha512-oUlH4h1ABavI4F0Xnl8/fOtML/eu8nI2A1nYd+f+55XI0BLu+RIqKoCiZKNo6DtqZBEQm5aNKA20G3Z5w3R6GQ==
dependencies:
"@eslint-community/regexpp" "^4.10.0"
- "@typescript-eslint/scope-manager" "8.24.0"
- "@typescript-eslint/type-utils" "8.24.0"
- "@typescript-eslint/utils" "8.24.0"
- "@typescript-eslint/visitor-keys" "8.24.0"
+ "@typescript-eslint/scope-manager" "8.31.1"
+ "@typescript-eslint/type-utils" "8.31.1"
+ "@typescript-eslint/utils" "8.31.1"
+ "@typescript-eslint/visitor-keys" "8.31.1"
graphemer "^1.4.0"
ignore "^5.3.1"
natural-compare "^1.4.0"
ts-api-utils "^2.0.1"
-"@typescript-eslint/parser@8.24.0", "@typescript-eslint/parser@^8.24.0":
- version "8.24.0"
- resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-8.24.0.tgz#bba837f9ee125b78f459ad947ff9b61be8139085"
- integrity sha512-MFDaO9CYiard9j9VepMNa9MTcqVvSny2N4hkY6roquzj8pdCBRENhErrteaQuu7Yjn1ppk0v1/ZF9CG3KIlrTA==
+"@typescript-eslint/parser@8.31.1":
+ version "8.31.1"
+ resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-8.31.1.tgz#e9b0ccf30d37dde724ee4d15f4dbc195995cce1b"
+ integrity sha512-oU/OtYVydhXnumd0BobL9rkJg7wFJ9bFFPmSmB/bf/XWN85hlViji59ko6bSKBXyseT9V8l+CN1nwmlbiN0G7Q==
dependencies:
- "@typescript-eslint/scope-manager" "8.24.0"
- "@typescript-eslint/types" "8.24.0"
- "@typescript-eslint/typescript-estree" "8.24.0"
- "@typescript-eslint/visitor-keys" "8.24.0"
+ "@typescript-eslint/scope-manager" "8.31.1"
+ "@typescript-eslint/types" "8.31.1"
+ "@typescript-eslint/typescript-estree" "8.31.1"
+ "@typescript-eslint/visitor-keys" "8.31.1"
debug "^4.3.4"
-"@typescript-eslint/scope-manager@8.24.0":
- version "8.24.0"
- resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-8.24.0.tgz#2e34b3eb2ce768f2ffb109474174ced5417002b1"
- integrity sha512-HZIX0UByphEtdVBKaQBgTDdn9z16l4aTUz8e8zPQnyxwHBtf5vtl1L+OhH+m1FGV9DrRmoDuYKqzVrvWDcDozw==
+"@typescript-eslint/scope-manager@8.31.1":
+ version "8.31.1"
+ resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-8.31.1.tgz#1eb52e76878f545e4add142e0d8e3e97e7aa443b"
+ integrity sha512-BMNLOElPxrtNQMIsFHE+3P0Yf1z0dJqV9zLdDxN/xLlWMlXK/ApEsVEKzpizg9oal8bAT5Sc7+ocal7AC1HCVw==
dependencies:
- "@typescript-eslint/types" "8.24.0"
- "@typescript-eslint/visitor-keys" "8.24.0"
+ "@typescript-eslint/types" "8.31.1"
+ "@typescript-eslint/visitor-keys" "8.31.1"
-"@typescript-eslint/type-utils@8.24.0":
- version "8.24.0"
- resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-8.24.0.tgz#6ee3ec4db06f9e5e7b01ca6c2b5dd5843a9fd1e8"
- integrity sha512-8fitJudrnY8aq0F1wMiPM1UUgiXQRJ5i8tFjq9kGfRajU+dbPyOuHbl0qRopLEidy0MwqgTHDt6CnSeXanNIwA==
+"@typescript-eslint/type-utils@8.31.1":
+ version "8.31.1"
+ resolved "https://registry.yarnpkg.com/@typescript-eslint/type-utils/-/type-utils-8.31.1.tgz#be0f438fb24b03568e282a0aed85f776409f970c"
+ integrity sha512-fNaT/m9n0+dpSp8G/iOQ05GoHYXbxw81x+yvr7TArTuZuCA6VVKbqWYVZrV5dVagpDTtj/O8k5HBEE/p/HM5LA==
dependencies:
- "@typescript-eslint/typescript-estree" "8.24.0"
- "@typescript-eslint/utils" "8.24.0"
+ "@typescript-eslint/typescript-estree" "8.31.1"
+ "@typescript-eslint/utils" "8.31.1"
debug "^4.3.4"
ts-api-utils "^2.0.1"
-"@typescript-eslint/types@8.24.0":
- version "8.24.0"
- resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-8.24.0.tgz#694e7fb18d70506c317b816de9521300b0f72c8e"
- integrity sha512-VacJCBTyje7HGAw7xp11q439A+zeGG0p0/p2zsZwpnMzjPB5WteaWqt4g2iysgGFafrqvyLWqq6ZPZAOCoefCw==
+"@typescript-eslint/types@8.31.1":
+ version "8.31.1"
+ resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-8.31.1.tgz#478ed6f7e8aee1be7b63a60212b6bffe1423b5d4"
+ integrity sha512-SfepaEFUDQYRoA70DD9GtytljBePSj17qPxFHA/h3eg6lPTqGJ5mWOtbXCk1YrVU1cTJRd14nhaXWFu0l2troQ==
-"@typescript-eslint/typescript-estree@8.24.0":
- version "8.24.0"
- resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-8.24.0.tgz#0487349be174097bb329a58273100a9629e03c6c"
- integrity sha512-ITjYcP0+8kbsvT9bysygfIfb+hBj6koDsu37JZG7xrCiy3fPJyNmfVtaGsgTUSEuTzcvME5YI5uyL5LD1EV5ZQ==
+"@typescript-eslint/typescript-estree@8.31.1":
+ version "8.31.1"
+ resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-8.31.1.tgz#37792fe7ef4d3021c7580067c8f1ae66daabacdf"
+ integrity sha512-kaA0ueLe2v7KunYOyWYtlf/QhhZb7+qh4Yw6Ni5kgukMIG+iP773tjgBiLWIXYumWCwEq3nLW+TUywEp8uEeag==
dependencies:
- "@typescript-eslint/types" "8.24.0"
- "@typescript-eslint/visitor-keys" "8.24.0"
+ "@typescript-eslint/types" "8.31.1"
+ "@typescript-eslint/visitor-keys" "8.31.1"
debug "^4.3.4"
fast-glob "^3.3.2"
is-glob "^4.0.3"
@@ -1024,22 +1024,22 @@
semver "^7.6.0"
ts-api-utils "^2.0.1"
-"@typescript-eslint/utils@8.24.0":
- version "8.24.0"
- resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-8.24.0.tgz#21cb1195ae79230af825bfeed59574f5cb70a749"
- integrity sha512-07rLuUBElvvEb1ICnafYWr4hk8/U7X9RDCOqd9JcAMtjh/9oRmcfN4yGzbPVirgMR0+HLVHehmu19CWeh7fsmQ==
+"@typescript-eslint/utils@8.31.1":
+ version "8.31.1"
+ resolved "https://registry.yarnpkg.com/@typescript-eslint/utils/-/utils-8.31.1.tgz#5628ea0393598a0b2f143d0fc6d019f0dee9dd14"
+ integrity sha512-2DSI4SNfF5T4oRveQ4nUrSjUqjMND0nLq9rEkz0gfGr3tg0S5KB6DhwR+WZPCjzkZl3cH+4x2ce3EsL50FubjQ==
dependencies:
"@eslint-community/eslint-utils" "^4.4.0"
- "@typescript-eslint/scope-manager" "8.24.0"
- "@typescript-eslint/types" "8.24.0"
- "@typescript-eslint/typescript-estree" "8.24.0"
+ "@typescript-eslint/scope-manager" "8.31.1"
+ "@typescript-eslint/types" "8.31.1"
+ "@typescript-eslint/typescript-estree" "8.31.1"
-"@typescript-eslint/visitor-keys@8.24.0":
- version "8.24.0"
- resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-8.24.0.tgz#36ecf0b9b1d819ad88a3bd4157ab7d594cb797c9"
- integrity sha512-kArLq83QxGLbuHrTMoOEWO+l2MwsNS2TGISEdx8xgqpkbytB07XmlQyQdNDrCc1ecSqx0cnmhGvpX+VBwqqSkg==
+"@typescript-eslint/visitor-keys@8.31.1":
+ version "8.31.1"
+ resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-8.31.1.tgz#6742b0e3ba1e0c1e35bdaf78c03e759eb8dd8e75"
+ integrity sha512-I+/rgqOVBn6f0o7NDTmAPWWC6NuqhV174lfYvAm9fUaWeiefLdux9/YI3/nLugEn9L8fcSi0XmpKi/r5u0nmpw==
dependencies:
- "@typescript-eslint/types" "8.24.0"
+ "@typescript-eslint/types" "8.31.1"
eslint-visitor-keys "^4.2.0"
acorn-jsx@^5.3.2:
@@ -3284,9 +3284,9 @@ ts-node@^10.5.0:
v8-compile-cache-lib "^3.0.0"
yn "3.1.1"
-"tsc-multi@https://github.com/stainless-api/tsc-multi/releases/download/v1.1.3/tsc-multi.tgz":
- version "1.1.3"
- resolved "https://github.com/stainless-api/tsc-multi/releases/download/v1.1.3/tsc-multi.tgz#8fc21fc95b247b86721b95fabfb10c6a436134c3"
+"tsc-multi@https://github.com/stainless-api/tsc-multi/releases/download/v1.1.4/tsc-multi-1.1.4.tgz":
+ version "1.1.4"
+ resolved "https://github.com/stainless-api/tsc-multi/releases/download/v1.1.4/tsc-multi-1.1.4.tgz#cbed459a9e902f5295ec3daaf1c7aa3b10427e55"
dependencies:
debug "^4.3.7"
fast-glob "^3.3.2"
@@ -3335,24 +3335,24 @@ type-fest@^0.21.3:
resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.21.3.tgz#d260a24b0198436e133fa26a524a6d65fa3b2e37"
integrity sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==
-typescript-eslint@^8.24.0:
- version "8.24.0"
- resolved "https://registry.yarnpkg.com/typescript-eslint/-/typescript-eslint-8.24.0.tgz#cc655e71885ecb8280342b422ad839a2e2e46a96"
- integrity sha512-/lmv4366en/qbB32Vz5+kCNZEMf6xYHwh1z48suBwZvAtnXKbP+YhGe8OLE2BqC67LMqKkCNLtjejdwsdW6uOQ==
+typescript-eslint@8.31.1:
+ version "8.31.1"
+ resolved "https://registry.yarnpkg.com/typescript-eslint/-/typescript-eslint-8.31.1.tgz#b77ab1e48ced2daab9225ff94bab54391a4af69b"
+ integrity sha512-j6DsEotD/fH39qKzXTQRwYYWlt7D+0HmfpOK+DVhwJOFLcdmn92hq3mBb7HlKJHbjjI/gTOqEcc9d6JfpFf/VA==
dependencies:
- "@typescript-eslint/eslint-plugin" "8.24.0"
- "@typescript-eslint/parser" "8.24.0"
- "@typescript-eslint/utils" "8.24.0"
+ "@typescript-eslint/eslint-plugin" "8.31.1"
+ "@typescript-eslint/parser" "8.31.1"
+ "@typescript-eslint/utils" "8.31.1"
typescript@5.6.1-rc:
version "5.6.1-rc"
resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.6.1-rc.tgz#d5e4d7d8170174fed607b74cc32aba3d77018e02"
integrity sha512-E3b2+1zEFu84jB0YQi9BORDjz9+jGbwwy1Zi3G0LUNw7a7cePUrHMRNy8aPh53nXpkFGVHSxIZo5vKTfYaFiBQ==
-typescript@^4.8.2:
- version "4.9.5"
- resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.9.5.tgz#095979f9bcc0d09da324d58d03ce8f8374cbe65a"
- integrity sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==
+typescript@5.8.3:
+ version "5.8.3"
+ resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.8.3.tgz#92f8a3e5e3cf497356f4178c34cd65a7f5e8440e"
+ integrity sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==
undici-types@~5.26.4:
version "5.26.5"