@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/dist/plus/git-github/api/github.utils.d.ts

@@ -1,9 +1,11 @@
-import type { PullRequestUrlIdentity } from '../../../git/utils/pullRequest.utils.js';
+import { PullRequestUrlIdentity } from "../../../git/utils/pullRequest.utils.js";
+//#region ../plus/git-github/src/api/github.utils.d.ts
 export declare function isMaybeGitHubPullRequestUrl(url: string): boolean;
 export declare function getGitHubPullRequestIdentityFromMaybeUrl(search: string): (PullRequestUrlIdentity & {
-    provider: undefined;
+  provider: undefined;
 }) | undefined;
 export declare function getGitHubPullRequestIdentityFromMaybeUrl<T extends string>(search: string, id: T): (PullRequestUrlIdentity & {
-    provider: T;
+  provider: T;
 }) | undefined;
+//#endregion
 //# sourceMappingURL=github.utils.d.ts.map

package/dist/plus/git-github/api/github.utils.js

@@ -1,22 +1,27 @@
-export function isMaybeGitHubPullRequestUrl(url) {
-    if (url == null)
-        return false;
-    return getGitHubPullRequestIdentityFromMaybeUrl(url) != null;
+//#region ../plus/git-github/src/api/github.utils.ts
+function isMaybeGitHubPullRequestUrl(url) {
+	if (url == null) return false;
+	return getGitHubPullRequestIdentityFromMaybeUrl(url) != null;
 }
-export function getGitHubPullRequestIdentityFromMaybeUrl(search, id) {
-    let ownerAndRepo = undefined;
-    let prNumber = undefined;
-    let match = search.match(/([^/]+\/[^/]+)\/(?:pull)\/(\d+)/); // with org and rep name
-    if (match != null) {
-        ownerAndRepo = match[1];
-        prNumber = match[2];
-    }
-    if (prNumber == null) {
-        match = search.match(/(?:\/|^)(?:pull)\/(\d+)/); // without repo name
-        if (match != null) {
-            prNumber = match[1];
-        }
-    }
-    return prNumber != null ? { ownerAndRepo: ownerAndRepo, prNumber: prNumber, provider: id } : undefined;
+function getGitHubPullRequestIdentityFromMaybeUrl(search, id) {
+	let ownerAndRepo = void 0;
+	let prNumber = void 0;
+	let match = search.match(/([^/]+\/[^/]+)\/(?:pull)\/(\d+)/);
+	if (match != null) {
+		ownerAndRepo = match[1];
+		prNumber = match[2];
+	}
+	if (prNumber == null) {
+		match = search.match(/(?:\/|^)(?:pull)\/(\d+)/);
+		if (match != null) prNumber = match[1];
+	}
+	return prNumber != null ? {
+		ownerAndRepo,
+		prNumber,
+		provider: id
+	} : void 0;
 }
+//#endregion
+export { getGitHubPullRequestIdentityFromMaybeUrl, isMaybeGitHubPullRequestUrl };
+
 //# sourceMappingURL=github.utils.js.map

package/dist/plus/git-github/api/github.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"github.utils.js","sourceRoot":"","sources":["../../../../src/plus/git-github/api/github.utils.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,2BAA2B,CAAC,GAAW;IACtD,IAAI,GAAG,IAAI,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9B,OAAO,wCAAwC,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC;AAC9D,CAAC;AASD,MAAM,UAAU,wCAAwC,CACvD,MAAc,EACd,EAAM;IAEN,IAAI,YAAY,GAAuB,SAAS,CAAC;IACjD,IAAI,QAAQ,GAAuB,SAAS,CAAC;IAE7C,IAAI,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,iCAAiC,CAAC,CAAC,CAAC,wBAAwB;IACrF,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;QACnB,YAAY,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACxB,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IACrB,CAAC;IAED,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;QACtB,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,yBAAyB,CAAC,CAAC,CAAC,oBAAoB;QACrE,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;YACnB,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QACrB,CAAC;IACF,CAAC;IAED,OAAO,QAAQ,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;AACxG,CAAC"}
+{"version":3,"file":"github.utils.js","names":[],"sources":["../../../../../plus/git-github/src/api/github.utils.ts"],"sourcesContent":["import type { PullRequestUrlIdentity } from '@gitlens/git/utils/pullRequest.utils.js';\n\nexport function isMaybeGitHubPullRequestUrl(url: string): boolean {\n\tif (url == null) return false;\n\treturn getGitHubPullRequestIdentityFromMaybeUrl(url) != null;\n}\n\nexport function getGitHubPullRequestIdentityFromMaybeUrl(\n\tsearch: string,\n): (PullRequestUrlIdentity & { provider: undefined }) | undefined;\nexport function getGitHubPullRequestIdentityFromMaybeUrl<T extends string>(\n\tsearch: string,\n\tid: T,\n): (PullRequestUrlIdentity & { provider: T }) | undefined;\nexport function getGitHubPullRequestIdentityFromMaybeUrl<T extends string>(\n\tsearch: string,\n\tid?: T,\n): (PullRequestUrlIdentity & { provider: T | undefined }) | undefined {\n\tlet ownerAndRepo: string | undefined = undefined;\n\tlet prNumber: string | undefined = undefined;\n\n\tlet match = search.match(/([^/]+\\/[^/]+)\\/(?:pull)\\/(\\d+)/); // with org and rep name\n\tif (match != null) {\n\t\townerAndRepo = match[1];\n\t\tprNumber = match[2];\n\t}\n\n\tif (prNumber == null) {\n\t\tmatch = search.match(/(?:\\/|^)(?:pull)\\/(\\d+)/); // without repo name\n\t\tif (match != null) {\n\t\t\tprNumber = match[1];\n\t\t}\n\t}\n\n\treturn prNumber != null ? { ownerAndRepo: ownerAndRepo, prNumber: prNumber, provider: id } : undefined;\n}\n"],"mappings":";AAEA,SAAgB,4BAA4B,KAAsB;CACjE,IAAI,OAAO,MAAM,OAAO;CACxB,OAAO,yCAAyC,GAAG,KAAK;AACzD;AASA,SAAgB,yCACf,QACA,IACqE;CACrE,IAAI,eAAmC,KAAA;CACvC,IAAI,WAA+B,KAAA;CAEnC,IAAI,QAAQ,OAAO,MAAM,iCAAiC;CAC1D,IAAI,SAAS,MAAM;EAClB,eAAe,MAAM;EACrB,WAAW,MAAM;CAClB;CAEA,IAAI,YAAY,MAAM;EACrB,QAAQ,OAAO,MAAM,yBAAyB;EAC9C,IAAI,SAAS,MACZ,WAAW,MAAM;CAEnB;CAEA,OAAO,YAAY,OAAO;EAAgB;EAAwB;EAAU,UAAU;CAAG,IAAI,KAAA;AAC9F"}

package/dist/plus/git-github/api/issueSearchQuery.d.ts

@@ -1,4 +1,5 @@
-import type { IssueSearchCriteria, IssueSearchRelationship, IssueSorting } from '../../../git/models/issue.js';
+import { IssueSearchCriteria, IssueSearchRelationship, IssueSorting } from "../../../git/models/issue.js";
+//#region ../plus/git-github/src/api/issueSearchQuery.d.ts
 /**
  * Translation of the provider-neutral issue-search criteria into GitHub search qualifiers, and the sanitizing
  * that keeps user input from becoming one.
@@ -45,8 +46,8 @@ export declare function sanitizeGitHubSearchText(text: string): string;
  * is added without both, rather than silently emitting an unconstrained search.
  */
 export declare const gitHubIssueSearchRelationships: Record<IssueSearchRelationship, {
-    qualifier: string;
-    alias: string;
+  qualifier: string;
+  alias: string;
 }>;
 /**
  * How each orderable key becomes a GitHub `sort:` qualifier.
@@ -124,4 +125,5 @@ export declare function toGitHubIssueSearchScopeQualifiers(org: string | undefin
  * as an empty qualifier.
  */
 export declare function toGitHubIssueSearchQualifiers(criteria: IssueSearchCriteria | undefined, sort: IssueSorting): string[];
+//#endregion
 //# sourceMappingURL=issueSearchQuery.d.ts.map

package/dist/plus/git-github/api/issueSearchQuery.js

@@ -1,242 +1,225 @@
+//#region ../plus/git-github/src/api/issueSearchQuery.ts
 /**
- * Translation of the provider-neutral issue-search criteria into GitHub search qualifiers, and the sanitizing
- * that keeps user input from becoming one.
- *
- * A module of its own because it is pure string building with no client, no token and no network — the part of the
- * search that is worth reading, testing and reasoning about on its own, and the part where a mistake is a
- * SECURITY mistake rather than a failed request: an unsanitized value that escapes its qualifier re-scopes
- * someone's search. Keeping it out of the 4000-line API client is what makes that reviewable.
- */
+* Translation of the provider-neutral issue-search criteria into GitHub search qualifiers, and the sanitizing
+* that keeps user input from becoming one.
+*
+* A module of its own because it is pure string building with no client, no token and no network — the part of the
+* search that is worth reading, testing and reasoning about on its own, and the part where a mistake is a
+* SECURITY mistake rather than a failed request: an unsanitized value that escapes its qualifier re-scopes
+* someone's search. Keeping it out of the 4000-line API client is what makes that reviewable.
+*/
 /**
- * Neutralizes everything in a user-supplied value that could break out of the qualifier it lands in: the double
- * quote that would close its own `"…"`, and the control characters that cannot appear in a GitHub search query
- * and exist here only as a smuggling vector.
- *
- * Not a general escape — GitHub search has no escape syntax — so the only safe transformation is removal. But a
- * control character is REPLACED WITH A SPACE rather than deleted, because deleting it FUSES the words it separated:
- * a pasted or multi-line `graph\nperformance` became the single token `graphperformance`, which matches nothing —
- * turning a search that had results into a silent zero (measured: 2 results vs 0). Quotes are still deleted
- * outright; they separate nothing, so a space there would only pad the value.
- *
- * Runs of whitespace are collapsed afterwards so the emitted qualifier stays canonical — a doubled space inside
- * `label:"a  b"` would not match the label `a b`.
- */
-export function sanitizeGitHubQualifierValue(value) {
-    return (value
-        .replace(/"/g, '')
-        // eslint-disable-next-line no-control-regex
-        .replace(/[\u0000-\u001f\u007f]/g, ' ')
-        .replace(/\s+/g, ' ')
-        .trim());
+* Neutralizes everything in a user-supplied value that could break out of the qualifier it lands in: the double
+* quote that would close its own `"…"`, and the control characters that cannot appear in a GitHub search query
+* and exist here only as a smuggling vector.
+*
+* Not a general escape — GitHub search has no escape syntax — so the only safe transformation is removal. But a
+* control character is REPLACED WITH A SPACE rather than deleted, because deleting it FUSES the words it separated:
+* a pasted or multi-line `graph\nperformance` became the single token `graphperformance`, which matches nothing —
+* turning a search that had results into a silent zero (measured: 2 results vs 0). Quotes are still deleted
+* outright; they separate nothing, so a space there would only pad the value.
+*
+* Runs of whitespace are collapsed afterwards so the emitted qualifier stays canonical — a doubled space inside
+* `label:"a  b"` would not match the label `a b`.
+*/
+function sanitizeGitHubQualifierValue(value) {
+	return value.replace(/"/g, "").replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim();
 }
 /**
- * Sanitizes free text, which is a different problem from a qualifier value: bare words are the POINT here, so it
- * can't just be quoted. What must not survive is anything that would read as a qualifier — GitHub parses any
- * whitespace-delimited `key:value` token as one, so a user typing `foo org:someone-else` would otherwise re-scope
- * the search to another org.
- *
- * Tokens containing `:` are dropped whole rather than having the colon removed: the remainder would silently
- * change what the user searched for, and a dropped token at least matches nothing extra. The structured criteria
- * are the qualifier channel.
- */
-export function sanitizeGitHubSearchText(text) {
-    return sanitizeGitHubQualifierValue(text)
-        .split(/\s+/)
-        .filter(token => token.length > 0 && !token.includes(':'))
-        .join(' ');
+* Sanitizes free text, which is a different problem from a qualifier value: bare words are the POINT here, so it
+* can't just be quoted. What must not survive is anything that would read as a qualifier — GitHub parses any
+* whitespace-delimited `key:value` token as one, so a user typing `foo org:someone-else` would otherwise re-scope
+* the search to another org.
+*
+* Tokens containing `:` are dropped whole rather than having the colon removed: the remainder would silently
+* change what the user searched for, and a dropped token at least matches nothing extra. The structured criteria
+* are the qualifier channel.
+*/
+function sanitizeGitHubSearchText(text) {
+	return sanitizeGitHubQualifierValue(text).split(/\s+/).filter((token) => token.length > 0 && !token.includes(":")).join(" ");
 }
 /**
- * How each relationship is expressed: its GitHub search qualifier (`@me` binds to the token's own user), and the
- * GraphQL alias its search runs under.
- *
- * The aliases are LITERALS rather than derived from the relationship name, for two reasons: `any-assignee` is not
- * a valid GraphQL name, and an alias is also a persisted cursor key (see {@link GitHubApi.searchIssuesByAlias}),
- * so it must be stable across releases — spelling them out makes that immovability visible instead of an
- * emergent property of a transform. Being a `Record` over the union, the type fails the build if a relationship
- * is added without both, rather than silently emitting an unconstrained search.
- */
-export const gitHubIssueSearchRelationships = {
-    authored: { qualifier: 'author:@me', alias: 'authored' },
-    assigned: { qualifier: 'assignee:@me', alias: 'assigned' },
-    mentioned: { qualifier: 'mentions:@me', alias: 'mentioned' },
-    'any-assignee': { qualifier: 'assignee:*', alias: 'anyAssignee' },
-    unassigned: { qualifier: 'no:assignee', alias: 'unassigned' },
+* How each relationship is expressed: its GitHub search qualifier (`@me` binds to the token's own user), and the
+* GraphQL alias its search runs under.
+*
+* The aliases are LITERALS rather than derived from the relationship name, for two reasons: `any-assignee` is not
+* a valid GraphQL name, and an alias is also a persisted cursor key (see {@link GitHubApi.searchIssuesByAlias}),
+* so it must be stable across releases — spelling them out makes that immovability visible instead of an
+* emergent property of a transform. Being a `Record` over the union, the type fails the build if a relationship
+* is added without both, rather than silently emitting an unconstrained search.
+*/
+const gitHubIssueSearchRelationships = {
+	authored: {
+		qualifier: "author:@me",
+		alias: "authored"
+	},
+	assigned: {
+		qualifier: "assignee:@me",
+		alias: "assigned"
+	},
+	mentioned: {
+		qualifier: "mentions:@me",
+		alias: "mentioned"
+	},
+	"any-assignee": {
+		qualifier: "assignee:*",
+		alias: "anyAssignee"
+	},
+	unassigned: {
+		qualifier: "no:assignee",
+		alias: "unassigned"
+	}
 };
 /**
- * How each orderable key becomes a GitHub `sort:` qualifier.
- *
- * A literal table rather than a derived transform, for the same reason {@link gitHubIssueSearchRelationships} is
- * one: being a `Record` over the union means adding a sort field without deciding its qualifier FAILS THE BUILD,
- * instead of quietly emitting a search with no ordering constraint at all — which is the one failure mode the
- * ordering contract exists to prevent, and the one a caller cannot detect from the result.
- *
- * `updated:desc` maps to the bare `sort:updated`, not `sort:updated-desc`. The two are the same query to GitHub,
- * but the bare form is what this read has always emitted, so keeping it makes the default byte-identical to
- * today's query — and the exact-query tests and recorded fixtures stay valid. Do not "normalize" it.
- *
- * `reactions` maps to the per-emoji `sort:reactions-+1`, NOT the bare `sort:reactions`. GitHub's bare form orders
- * by the total across every reaction type, but the only reaction count on an `IssueShape` is `thumbsUpCount`,
- * which this client fills from `reactions(content: THUMBS_UP)`. Ordering by the total would rank the page by a
- * number the caller cannot see — and would disagree with `getIssueComparator`, which re-sorts a merged page from
- * `thumbsUpCount`, so the same request would order one way with a single relationship and another way with two.
- * `@gitkraken/provider-apis` maps it the same way for the same reason.
- *
- * Absent keys are absent on purpose: `closed` is NOT here even though `IssueShape.closedDate` exists, because
- * GitHub's search cannot order by close date and a client-side sort over a page cut off at the result ceiling is
- * exactly the lie the contract avoids. `sorts` in `githubIssueSearchCapabilities` is the same set, and a parity
- * test pins the two together.
- */
-export const gitHubIssueSortQualifiers = {
-    'created:asc': 'sort:created-asc',
-    'created:desc': 'sort:created-desc',
-    'updated:asc': 'sort:updated-asc',
-    'updated:desc': 'sort:updated',
-    'comments:asc': 'sort:comments-asc',
-    'comments:desc': 'sort:comments-desc',
-    'reactions:asc': 'sort:reactions-+1-asc',
-    'reactions:desc': 'sort:reactions-+1-desc',
+* How each orderable key becomes a GitHub `sort:` qualifier.
+*
+* A literal table rather than a derived transform, for the same reason {@link gitHubIssueSearchRelationships} is
+* one: being a `Record` over the union means adding a sort field without deciding its qualifier FAILS THE BUILD,
+* instead of quietly emitting a search with no ordering constraint at all — which is the one failure mode the
+* ordering contract exists to prevent, and the one a caller cannot detect from the result.
+*
+* `updated:desc` maps to the bare `sort:updated`, not `sort:updated-desc`. The two are the same query to GitHub,
+* but the bare form is what this read has always emitted, so keeping it makes the default byte-identical to
+* today's query — and the exact-query tests and recorded fixtures stay valid. Do not "normalize" it.
+*
+* `reactions` maps to the per-emoji `sort:reactions-+1`, NOT the bare `sort:reactions`. GitHub's bare form orders
+* by the total across every reaction type, but the only reaction count on an `IssueShape` is `thumbsUpCount`,
+* which this client fills from `reactions(content: THUMBS_UP)`. Ordering by the total would rank the page by a
+* number the caller cannot see — and would disagree with `getIssueComparator`, which re-sorts a merged page from
+* `thumbsUpCount`, so the same request would order one way with a single relationship and another way with two.
+* `@gitkraken/provider-apis` maps it the same way for the same reason.
+*
+* Absent keys are absent on purpose: `closed` is NOT here even though `IssueShape.closedDate` exists, because
+* GitHub's search cannot order by close date and a client-side sort over a page cut off at the result ceiling is
+* exactly the lie the contract avoids. `sorts` in `githubIssueSearchCapabilities` is the same set, and a parity
+* test pins the two together.
+*/
+const gitHubIssueSortQualifiers = {
+	"created:asc": "sort:created-asc",
+	"created:desc": "sort:created-desc",
+	"updated:asc": "sort:updated-asc",
+	"updated:desc": "sort:updated",
+	"comments:asc": "sort:comments-asc",
+	"comments:desc": "sort:comments-desc",
+	"reactions:asc": "sort:reactions-+1-asc",
+	"reactions:desc": "sort:reactions-+1-desc"
 };
 /**
- * The `sort:` qualifier for a key, or `undefined` when there is no key or GitHub can't express it.
- *
- * Applies no default of its own: the two callers differ on whether they HAVE one — the filtered search always
- * orders, and `searchMyIssues` has never requested an order at all — so the default belongs at the call site that
- * has one rather than behind a guard at the one that doesn't.
- *
- * `undefined` for an inexpressible key rather than a fallback to something orderable: every caller validated
- * against the declared capability first, so reaching that case means the capability table has outrun this one, and
- * a silently unordered search would change which rows land inside the result ceiling.
- */
-export function toGitHubIssueSortQualifier(sort) {
-    return sort != null ? gitHubIssueSortQualifiers[sort] : undefined;
+* The `sort:` qualifier for a key, or `undefined` when there is no key or GitHub can't express it.
+*
+* Applies no default of its own: the two callers differ on whether they HAVE one — the filtered search always
+* orders, and `searchMyIssues` has never requested an order at all — so the default belongs at the call site that
+* has one rather than behind a guard at the one that doesn't.
+*
+* `undefined` for an inexpressible key rather than a fallback to something orderable: every caller validated
+* against the declared capability first, so reaching that case means the capability table has outrun this one, and
+* a silently unordered search would change which rows land inside the result ceiling.
+*/
+function toGitHubIssueSortQualifier(sort) {
+	return sort != null ? gitHubIssueSortQualifiers[sort] : void 0;
 }
 /**
- * The sort keys a CEILING SLIDE can continue past, and the qualifier each one continues with.
- *
- * The slide works by re-issuing the search bounded to the far side of what has already been served, which needs
- * two things from the sort key: a value carried on the returned issue (so the boundary can be read off the last
- * item), and a GitHub range qualifier over that same value (so the continuation can be expressed). Only the two
- * date keys have both. `comments`/`reactions` have range qualifiers but their values are unstable under
- * concurrent activity — a comment added mid-walk moves an issue across the boundary, which would drop or repeat
- * it — and `title` has no range qualifier at all. Those keep reporting the ceiling instead, which is correct
- * rather than a gap: the read stays truthful about what it could not reach.
- *
- * A `Partial<Record<…>>` over the union rather than a lookup with a default, so a sort key added later is
- * NOT-slidable by construction and has to be opted in deliberately.
- */
+* The sort keys a CEILING SLIDE can continue past, and the qualifier each one continues with.
+*
+* The slide works by re-issuing the search bounded to the far side of what has already been served, which needs
+* two things from the sort key: a value carried on the returned issue (so the boundary can be read off the last
+* item), and a GitHub range qualifier over that same value (so the continuation can be expressed). Only the two
+* date keys have both. `comments`/`reactions` have range qualifiers but their values are unstable under
+* concurrent activity — a comment added mid-walk moves an issue across the boundary, which would drop or repeat
+* it — and `title` has no range qualifier at all. Those keep reporting the ceiling instead, which is correct
+* rather than a gap: the read stays truthful about what it could not reach.
+*
+* A `Partial<Record<…>>` over the union rather than a lookup with a default, so a sort key added later is
+* NOT-slidable by construction and has to be opted in deliberately.
+*/
 const gitHubSlidableSortFields = {
-    created: 'created',
-    updated: 'updated',
+	created: "created",
+	updated: "updated"
 };
 /**
- * The qualifier that continues a search past the provider's result ceiling: everything at or beyond the last
- * item already served, under the same key the search is ordered by.
- *
- * INCLUSIVE (`<=` / `>=`) rather than exclusive, and that is a correctness requirement rather than a preference.
- * GitHub timestamps have one-second resolution and ties genuinely occur (measured: one shared second in a
- * 100-issue sample), so an exclusive bound would silently drop every issue sharing the boundary second with the
- * last one served. Being inclusive re-serves that second instead, which the caller dedupes.
- *
- * Returns `undefined` when the key can't be slid ({@link gitHubSlidableSortFields}), which is the signal to
- * report the ceiling rather than to continue.
- */
-export function toGitHubIssueSearchSlideQualifier(sort, boundary) {
-    const [field, direction] = sort.split(':');
-    const qualifier = gitHubSlidableSortFields[field];
-    if (qualifier == null)
-        return undefined;
-    // Whole seconds, matching both GitHub's own resolution and what its range qualifiers accept.
-    const value = boundary.toISOString().replace(/\.\d{3}Z$/, 'Z');
-    // Descending walks toward older, so the remainder is everything at or BEFORE the boundary; ascending is the
-    // mirror. Getting this backwards would re-request the half already served, forever.
-    return `${qualifier}:${direction === 'desc' ? '<=' : '>='}${value}`;
+* The qualifier that continues a search past the provider's result ceiling: everything at or beyond the last
+* item already served, under the same key the search is ordered by.
+*
+* INCLUSIVE (`<=` / `>=`) rather than exclusive, and that is a correctness requirement rather than a preference.
+* GitHub timestamps have one-second resolution and ties genuinely occur (measured: one shared second in a
+* 100-issue sample), so an exclusive bound would silently drop every issue sharing the boundary second with the
+* last one served. Being inclusive re-serves that second instead, which the caller dedupes.
+*
+* Returns `undefined` when the key can't be slid ({@link gitHubSlidableSortFields}), which is the signal to
+* report the ceiling rather than to continue.
+*/
+function toGitHubIssueSearchSlideQualifier(sort, boundary) {
+	const [field, direction] = sort.split(":");
+	const qualifier = gitHubSlidableSortFields[field];
+	if (qualifier == null) return void 0;
+	const value = boundary.toISOString().replace(/\.\d{3}Z$/, "Z");
+	return `${qualifier}:${direction === "desc" ? "<=" : ">="}${value}`;
 }
 /**
- * The scope half of an issue search query: `org:` plus one `repo:` per repository.
- *
- * Shared by the search and the count probe rather than written twice, because the count is only meaningful if it
- * applies EXACTLY the qualifiers the search would — a count under different constraints is a wrong number, not a
- * missing one. A value emptied by sanitizing is dropped rather than emitted as a bare `org:`/`repo:`, which
- * GitHub rejects; that is the same rule {@link toGitHubIssueSearchQualifiers} applies to its own values.
- */
-export function toGitHubIssueSearchScopeQualifiers(org, repos) {
-    const qualifiers = [];
-    if (org != null) {
-        const value = sanitizeGitHubQualifierValue(org);
-        if (value.length > 0) {
-            qualifiers.push(`org:${value}`);
-        }
-    }
-    for (const repo of repos ?? []) {
-        const value = sanitizeGitHubQualifierValue(repo);
-        if (value.length > 0) {
-            qualifiers.push(`repo:${value}`);
-        }
-    }
-    return qualifiers;
+* The scope half of an issue search query: `org:` plus one `repo:` per repository.
+*
+* Shared by the search and the count probe rather than written twice, because the count is only meaningful if it
+* applies EXACTLY the qualifiers the search would — a count under different constraints is a wrong number, not a
+* missing one. A value emptied by sanitizing is dropped rather than emitted as a bare `org:`/`repo:`, which
+* GitHub rejects; that is the same rule {@link toGitHubIssueSearchQualifiers} applies to its own values.
+*/
+function toGitHubIssueSearchScopeQualifiers(org, repos) {
+	const qualifiers = [];
+	if (org != null) {
+		const value = sanitizeGitHubQualifierValue(org);
+		if (value.length > 0) qualifiers.push(`org:${value}`);
+	}
+	for (const repo of repos ?? []) {
+		const value = sanitizeGitHubQualifierValue(repo);
+		if (value.length > 0) qualifiers.push(`repo:${value}`);
+	}
+	return qualifiers;
 }
 /**
- * Translates the provider-neutral criteria into GitHub search qualifiers, EXCLUDING the relationship (which
- * becomes its own aliased search, since GitHub AND-s qualifiers and relationships are OR-ed) and excluding the
- * repository/org scope (which {@link toGitHubIssueSearchScopeQualifiers} owns).
- *
- * A `sort:` qualifier is ALWAYS emitted. Never none: the provider serves at most a bounded window of matches, and
- * without an explicit order GitHub answers in relevance order, so which rows land inside that window would shift
- * with GitHub's ranking even when nothing changed upstream. A key GitHub can't express is refused before this by
- * the facade, so it cannot arrive here.
- *
- * `sort` is passed in rather than read off `criteria` so that the qualifier this emits and the key the caller
- * records elsewhere cannot disagree — see `effectiveIssueSort`.
- *
- * Free-form values go through the sanitizers above, and one emptied by sanitizing is dropped rather than emitted
- * as an empty qualifier.
- */
-export function toGitHubIssueSearchQualifiers(criteria, sort) {
-    const qualifiers = ['type:issue'];
-    switch (criteria?.state) {
-        case 'closed':
-            qualifiers.push('is:closed');
-            break;
-        // Every state — no qualifier constrains it.
-        case 'all':
-            break;
-        default:
-            qualifiers.push('is:open');
-            break;
-    }
-    if (criteria?.includeArchived !== true) {
-        qualifiers.push('archived:false');
-    }
-    // One place to keep the "a value emptied by sanitizing is DROPPED, never emitted as an empty qualifier" rule,
-    // so a criterion added later can't skip it — a bare `milestone:""` is rejected by GitHub outright.
-    const pushSanitized = (value, toQualifier) => {
-        if (value == null)
-            return;
-        const sanitized = sanitizeGitHubQualifierValue(value);
-        if (sanitized.length > 0) {
-            qualifiers.push(toQualifier(sanitized));
-        }
-    };
-    for (const label of criteria?.labels ?? []) {
-        pushSanitized(label, v => `label:"${v}"`);
-    }
-    pushSanitized(criteria?.milestone, v => `milestone:"${v}"`);
-    pushSanitized(criteria?.updatedAfter, v => `updated:>=${v}`);
-    pushSanitized(criteria?.createdAfter, v => `created:>=${v}`);
-    if (criteria?.withoutLinkedPullRequest === true) {
-        qualifiers.push('-linked:pr');
-    }
-    if (criteria?.text != null) {
-        const text = sanitizeGitHubSearchText(criteria.text);
-        if (text.length > 0) {
-            qualifiers.push(text);
-        }
-    }
-    // Last, where it has always been: the exact-query tests pin the whole qualifier string, not a set.
-    const sortQualifier = toGitHubIssueSortQualifier(sort);
-    if (sortQualifier != null) {
-        qualifiers.push(sortQualifier);
-    }
-    return qualifiers;
+* Translates the provider-neutral criteria into GitHub search qualifiers, EXCLUDING the relationship (which
+* becomes its own aliased search, since GitHub AND-s qualifiers and relationships are OR-ed) and excluding the
+* repository/org scope (which {@link toGitHubIssueSearchScopeQualifiers} owns).
+*
+* A `sort:` qualifier is ALWAYS emitted. Never none: the provider serves at most a bounded window of matches, and
+* without an explicit order GitHub answers in relevance order, so which rows land inside that window would shift
+* with GitHub's ranking even when nothing changed upstream. A key GitHub can't express is refused before this by
+* the facade, so it cannot arrive here.
+*
+* `sort` is passed in rather than read off `criteria` so that the qualifier this emits and the key the caller
+* records elsewhere cannot disagree — see `effectiveIssueSort`.
+*
+* Free-form values go through the sanitizers above, and one emptied by sanitizing is dropped rather than emitted
+* as an empty qualifier.
+*/
+function toGitHubIssueSearchQualifiers(criteria, sort) {
+	const qualifiers = ["type:issue"];
+	switch (criteria?.state) {
+		case "closed":
+			qualifiers.push("is:closed");
+			break;
+		case "all": break;
+		default: qualifiers.push("is:open");
+	}
+	if (criteria?.includeArchived !== true) qualifiers.push("archived:false");
+	const pushSanitized = (value, toQualifier) => {
+		if (value == null) return;
+		const sanitized = sanitizeGitHubQualifierValue(value);
+		if (sanitized.length > 0) qualifiers.push(toQualifier(sanitized));
+	};
+	for (const label of criteria?.labels ?? []) pushSanitized(label, (v) => `label:"${v}"`);
+	pushSanitized(criteria?.milestone, (v) => `milestone:"${v}"`);
+	pushSanitized(criteria?.updatedAfter, (v) => `updated:>=${v}`);
+	pushSanitized(criteria?.createdAfter, (v) => `created:>=${v}`);
+	if (criteria?.withoutLinkedPullRequest === true) qualifiers.push("-linked:pr");
+	if (criteria?.text != null) {
+		const text = sanitizeGitHubSearchText(criteria.text);
+		if (text.length > 0) qualifiers.push(text);
+	}
+	const sortQualifier = toGitHubIssueSortQualifier(sort);
+	if (sortQualifier != null) qualifiers.push(sortQualifier);
+	return qualifiers;
 }
+//#endregion
+export { gitHubIssueSearchRelationships, gitHubIssueSortQualifiers, sanitizeGitHubQualifierValue, sanitizeGitHubSearchText, toGitHubIssueSearchQualifiers, toGitHubIssueSearchScopeQualifiers, toGitHubIssueSearchSlideQualifier, toGitHubIssueSortQualifier };
+
 //# sourceMappingURL=issueSearchQuery.js.map

package/dist/plus/git-github/api/issueSearchQuery.js.map

@@ -1 +1 @@
-{"version":3,"file":"issueSearchQuery.js","sourceRoot":"","sources":["../../../../src/plus/git-github/api/issueSearchQuery.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"issueSearchQuery.js","names":[],"sources":["../../../../../plus/git-github/src/api/issueSearchQuery.ts"],"sourcesContent":["import type {\n\tIssueSearchCriteria,\n\tIssueSearchRelationship,\n\tIssueSortField,\n\tIssueSorting,\n} from '@gitlens/git/models/issue.js';\n\n/**\n * Translation of the provider-neutral issue-search criteria into GitHub search qualifiers, and the sanitizing\n * that keeps user input from becoming one.\n *\n * A module of its own because it is pure string building with no client, no token and no network — the part of the\n * search that is worth reading, testing and reasoning about on its own, and the part where a mistake is a\n * SECURITY mistake rather than a failed request: an unsanitized value that escapes its qualifier re-scopes\n * someone's search. Keeping it out of the 4000-line API client is what makes that reviewable.\n */\n\n/**\n * Neutralizes everything in a user-supplied value that could break out of the qualifier it lands in: the double\n * quote that would close its own `\"…\"`, and the control characters that cannot appear in a GitHub search query\n * and exist here only as a smuggling vector.\n *\n * Not a general escape — GitHub search has no escape syntax — so the only safe transformation is removal. But a\n * control character is REPLACED WITH A SPACE rather than deleted, because deleting it FUSES the words it separated:\n * a pasted or multi-line `graph\\nperformance` became the single token `graphperformance`, which matches nothing —\n * turning a search that had results into a silent zero (measured: 2 results vs 0). Quotes are still deleted\n * outright; they separate nothing, so a space there would only pad the value.\n *\n * Runs of whitespace are collapsed afterwards so the emitted qualifier stays canonical — a doubled space inside\n * `label:\"a  b\"` would not match the label `a b`.\n */\nexport function sanitizeGitHubQualifierValue(value: string): string {\n\treturn (\n\t\tvalue\n\t\t\t.replace(/\"/g, '')\n\t\t\t// eslint-disable-next-line no-control-regex\n\t\t\t.replace(/[\\u0000-\\u001f\\u007f]/g, ' ')\n\t\t\t.replace(/\\s+/g, ' ')\n\t\t\t.trim()\n\t);\n}\n\n/**\n * Sanitizes free text, which is a different problem from a qualifier value: bare words are the POINT here, so it\n * can't just be quoted. What must not survive is anything that would read as a qualifier — GitHub parses any\n * whitespace-delimited `key:value` token as one, so a user typing `foo org:someone-else` would otherwise re-scope\n * the search to another org.\n *\n * Tokens containing `:` are dropped whole rather than having the colon removed: the remainder would silently\n * change what the user searched for, and a dropped token at least matches nothing extra. The structured criteria\n * are the qualifier channel.\n */\nexport function sanitizeGitHubSearchText(text: string): string {\n\treturn sanitizeGitHubQualifierValue(text)\n\t\t.split(/\\s+/)\n\t\t.filter(token => token.length > 0 && !token.includes(':'))\n\t\t.join(' ');\n}\n\n/**\n * How each relationship is expressed: its GitHub search qualifier (`@me` binds to the token's own user), and the\n * GraphQL alias its search runs under.\n *\n * The aliases are LITERALS rather than derived from the relationship name, for two reasons: `any-assignee` is not\n * a valid GraphQL name, and an alias is also a persisted cursor key (see {@link GitHubApi.searchIssuesByAlias}),\n * so it must be stable across releases — spelling them out makes that immovability visible instead of an\n * emergent property of a transform. Being a `Record` over the union, the type fails the build if a relationship\n * is added without both, rather than silently emitting an unconstrained search.\n */\nexport const gitHubIssueSearchRelationships: Record<IssueSearchRelationship, { qualifier: string; alias: string }> = {\n\tauthored: { qualifier: 'author:@me', alias: 'authored' },\n\tassigned: { qualifier: 'assignee:@me', alias: 'assigned' },\n\tmentioned: { qualifier: 'mentions:@me', alias: 'mentioned' },\n\t'any-assignee': { qualifier: 'assignee:*', alias: 'anyAssignee' },\n\tunassigned: { qualifier: 'no:assignee', alias: 'unassigned' },\n};\n\n/**\n * How each orderable key becomes a GitHub `sort:` qualifier.\n *\n * A literal table rather than a derived transform, for the same reason {@link gitHubIssueSearchRelationships} is\n * one: being a `Record` over the union means adding a sort field without deciding its qualifier FAILS THE BUILD,\n * instead of quietly emitting a search with no ordering constraint at all — which is the one failure mode the\n * ordering contract exists to prevent, and the one a caller cannot detect from the result.\n *\n * `updated:desc` maps to the bare `sort:updated`, not `sort:updated-desc`. The two are the same query to GitHub,\n * but the bare form is what this read has always emitted, so keeping it makes the default byte-identical to\n * today's query — and the exact-query tests and recorded fixtures stay valid. Do not \"normalize\" it.\n *\n * `reactions` maps to the per-emoji `sort:reactions-+1`, NOT the bare `sort:reactions`. GitHub's bare form orders\n * by the total across every reaction type, but the only reaction count on an `IssueShape` is `thumbsUpCount`,\n * which this client fills from `reactions(content: THUMBS_UP)`. Ordering by the total would rank the page by a\n * number the caller cannot see — and would disagree with `getIssueComparator`, which re-sorts a merged page from\n * `thumbsUpCount`, so the same request would order one way with a single relationship and another way with two.\n * `@gitkraken/provider-apis` maps it the same way for the same reason.\n *\n * Absent keys are absent on purpose: `closed` is NOT here even though `IssueShape.closedDate` exists, because\n * GitHub's search cannot order by close date and a client-side sort over a page cut off at the result ceiling is\n * exactly the lie the contract avoids. `sorts` in `githubIssueSearchCapabilities` is the same set, and a parity\n * test pins the two together.\n */\nexport const gitHubIssueSortQualifiers: Partial<Record<IssueSorting, string>> = {\n\t'created:asc': 'sort:created-asc',\n\t'created:desc': 'sort:created-desc',\n\t'updated:asc': 'sort:updated-asc',\n\t'updated:desc': 'sort:updated',\n\t'comments:asc': 'sort:comments-asc',\n\t'comments:desc': 'sort:comments-desc',\n\t'reactions:asc': 'sort:reactions-+1-asc',\n\t'reactions:desc': 'sort:reactions-+1-desc',\n};\n\n/**\n * The `sort:` qualifier for a key, or `undefined` when there is no key or GitHub can't express it.\n *\n * Applies no default of its own: the two callers differ on whether they HAVE one — the filtered search always\n * orders, and `searchMyIssues` has never requested an order at all — so the default belongs at the call site that\n * has one rather than behind a guard at the one that doesn't.\n *\n * `undefined` for an inexpressible key rather than a fallback to something orderable: every caller validated\n * against the declared capability first, so reaching that case means the capability table has outrun this one, and\n * a silently unordered search would change which rows land inside the result ceiling.\n */\nexport function toGitHubIssueSortQualifier(sort: IssueSorting | undefined): string | undefined {\n\treturn sort != null ? gitHubIssueSortQualifiers[sort] : undefined;\n}\n\n/**\n * The sort keys a CEILING SLIDE can continue past, and the qualifier each one continues with.\n *\n * The slide works by re-issuing the search bounded to the far side of what has already been served, which needs\n * two things from the sort key: a value carried on the returned issue (so the boundary can be read off the last\n * item), and a GitHub range qualifier over that same value (so the continuation can be expressed). Only the two\n * date keys have both. `comments`/`reactions` have range qualifiers but their values are unstable under\n * concurrent activity — a comment added mid-walk moves an issue across the boundary, which would drop or repeat\n * it — and `title` has no range qualifier at all. Those keep reporting the ceiling instead, which is correct\n * rather than a gap: the read stays truthful about what it could not reach.\n *\n * A `Partial<Record<…>>` over the union rather than a lookup with a default, so a sort key added later is\n * NOT-slidable by construction and has to be opted in deliberately.\n */\nconst gitHubSlidableSortFields: Partial<Record<IssueSortField, string>> = {\n\tcreated: 'created',\n\tupdated: 'updated',\n};\n\n/**\n * The qualifier that continues a search past the provider's result ceiling: everything at or beyond the last\n * item already served, under the same key the search is ordered by.\n *\n * INCLUSIVE (`<=` / `>=`) rather than exclusive, and that is a correctness requirement rather than a preference.\n * GitHub timestamps have one-second resolution and ties genuinely occur (measured: one shared second in a\n * 100-issue sample), so an exclusive bound would silently drop every issue sharing the boundary second with the\n * last one served. Being inclusive re-serves that second instead, which the caller dedupes.\n *\n * Returns `undefined` when the key can't be slid ({@link gitHubSlidableSortFields}), which is the signal to\n * report the ceiling rather than to continue.\n */\nexport function toGitHubIssueSearchSlideQualifier(sort: IssueSorting, boundary: Date): string | undefined {\n\tconst [field, direction] = sort.split(':') as [IssueSortField, 'asc' | 'desc'];\n\tconst qualifier = gitHubSlidableSortFields[field];\n\tif (qualifier == null) return undefined;\n\n\t// Whole seconds, matching both GitHub's own resolution and what its range qualifiers accept.\n\tconst value = boundary.toISOString().replace(/\\.\\d{3}Z$/, 'Z');\n\t// Descending walks toward older, so the remainder is everything at or BEFORE the boundary; ascending is the\n\t// mirror. Getting this backwards would re-request the half already served, forever.\n\treturn `${qualifier}:${direction === 'desc' ? '<=' : '>='}${value}`;\n}\n\n/**\n * The scope half of an issue search query: `org:` plus one `repo:` per repository.\n *\n * Shared by the search and the count probe rather than written twice, because the count is only meaningful if it\n * applies EXACTLY the qualifiers the search would — a count under different constraints is a wrong number, not a\n * missing one. A value emptied by sanitizing is dropped rather than emitted as a bare `org:`/`repo:`, which\n * GitHub rejects; that is the same rule {@link toGitHubIssueSearchQualifiers} applies to its own values.\n */\nexport function toGitHubIssueSearchScopeQualifiers(\n\torg: string | undefined,\n\trepos: readonly string[] | undefined,\n): string[] {\n\tconst qualifiers: string[] = [];\n\n\tif (org != null) {\n\t\tconst value = sanitizeGitHubQualifierValue(org);\n\t\tif (value.length > 0) {\n\t\t\tqualifiers.push(`org:${value}`);\n\t\t}\n\t}\n\n\tfor (const repo of repos ?? []) {\n\t\tconst value = sanitizeGitHubQualifierValue(repo);\n\t\tif (value.length > 0) {\n\t\t\tqualifiers.push(`repo:${value}`);\n\t\t}\n\t}\n\n\treturn qualifiers;\n}\n\n/**\n * Translates the provider-neutral criteria into GitHub search qualifiers, EXCLUDING the relationship (which\n * becomes its own aliased search, since GitHub AND-s qualifiers and relationships are OR-ed) and excluding the\n * repository/org scope (which {@link toGitHubIssueSearchScopeQualifiers} owns).\n *\n * A `sort:` qualifier is ALWAYS emitted. Never none: the provider serves at most a bounded window of matches, and\n * without an explicit order GitHub answers in relevance order, so which rows land inside that window would shift\n * with GitHub's ranking even when nothing changed upstream. A key GitHub can't express is refused before this by\n * the facade, so it cannot arrive here.\n *\n * `sort` is passed in rather than read off `criteria` so that the qualifier this emits and the key the caller\n * records elsewhere cannot disagree — see `effectiveIssueSort`.\n *\n * Free-form values go through the sanitizers above, and one emptied by sanitizing is dropped rather than emitted\n * as an empty qualifier.\n */\nexport function toGitHubIssueSearchQualifiers(criteria: IssueSearchCriteria | undefined, sort: IssueSorting): string[] {\n\tconst qualifiers = ['type:issue'];\n\n\tswitch (criteria?.state) {\n\t\tcase 'closed':\n\t\t\tqualifiers.push('is:closed');\n\t\t\tbreak;\n\t\t// Every state — no qualifier constrains it.\n\t\tcase 'all':\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tqualifiers.push('is:open');\n\t\t\tbreak;\n\t}\n\n\tif (criteria?.includeArchived !== true) {\n\t\tqualifiers.push('archived:false');\n\t}\n\n\t// One place to keep the \"a value emptied by sanitizing is DROPPED, never emitted as an empty qualifier\" rule,\n\t// so a criterion added later can't skip it — a bare `milestone:\"\"` is rejected by GitHub outright.\n\tconst pushSanitized = (value: string | undefined, toQualifier: (sanitized: string) => string): void => {\n\t\tif (value == null) return;\n\n\t\tconst sanitized = sanitizeGitHubQualifierValue(value);\n\t\tif (sanitized.length > 0) {\n\t\t\tqualifiers.push(toQualifier(sanitized));\n\t\t}\n\t};\n\n\tfor (const label of criteria?.labels ?? []) {\n\t\tpushSanitized(label, v => `label:\"${v}\"`);\n\t}\n\tpushSanitized(criteria?.milestone, v => `milestone:\"${v}\"`);\n\tpushSanitized(criteria?.updatedAfter, v => `updated:>=${v}`);\n\tpushSanitized(criteria?.createdAfter, v => `created:>=${v}`);\n\n\tif (criteria?.withoutLinkedPullRequest === true) {\n\t\tqualifiers.push('-linked:pr');\n\t}\n\n\tif (criteria?.text != null) {\n\t\tconst text = sanitizeGitHubSearchText(criteria.text);\n\t\tif (text.length > 0) {\n\t\t\tqualifiers.push(text);\n\t\t}\n\t}\n\n\t// Last, where it has always been: the exact-query tests pin the whole qualifier string, not a set.\n\tconst sortQualifier = toGitHubIssueSortQualifier(sort);\n\tif (sortQualifier != null) {\n\t\tqualifiers.push(sortQualifier);\n\t}\n\n\treturn qualifiers;\n}\n"],"mappings":"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"}