@cookbook/urlkit 1.0.0

package/dist/static.js

@@ -0,0 +1,55 @@
+import { a as compilePath, U as UrlKitError } from './compile-path-wQfWAzOh.js';
+export { h as hasPathConstraint, r as registerPathConstraint, f as registerPathConstraints } from './compile-path-wQfWAzOh.js';
+export { createConstraint } from '@cookbook/pathkit/constraints';
+import { c as compileStaticHash, a as compileStaticSearch } from './compile-static-search-Cq3uaLe8.js';
+import '@cookbook/pathkit/compile';
+import '@cookbook/pathkit/match';
+
+function compileStaticUrl(descriptor, options = {}) {
+    assertStaticUrlDescriptor(descriptor);
+    const mode = Object.prototype.hasOwnProperty.call(descriptor, 'path') ? 'path' : 'pathless';
+    const normalized = {
+        mode,
+        pattern: mode === 'path' ? descriptor.path : undefined,
+        ...(mode === 'path' && descriptor.path !== undefined
+            ? {
+                path: compilePath(descriptor.path, {
+                    params: 'parsed',
+                    ...(options.pathConstraints ? { pathConstraints: options.pathConstraints } : {}),
+                }),
+            }
+            : {}),
+        ...(Object.prototype.hasOwnProperty.call(descriptor, 'search')
+            ? { search: compileStaticSearch(descriptor.search ?? {}) }
+            : {}),
+        ...(Object.prototype.hasOwnProperty.call(descriptor, 'hash') && descriptor.hash !== undefined
+            ? { hash: compileStaticHash(descriptor.hash) }
+            : {}),
+    };
+    return Object.freeze(normalized);
+}
+function assertStaticUrlDescriptor(input) {
+    if (!isRecord(input)) {
+        throw new UrlKitError('invalid-descriptor', 'Static URL descriptor must be an object.', {
+            path: [],
+        });
+    }
+    if (Object.prototype.hasOwnProperty.call(input, 'path') && typeof input.path !== 'string') {
+        throw new UrlKitError('invalid-descriptor', 'Static URL descriptor path must be a string.', {
+            path: ['path'],
+        });
+    }
+    if (Object.prototype.hasOwnProperty.call(input, 'search') &&
+        input.search !== undefined &&
+        !isRecord(input.search)) {
+        throw new UrlKitError('invalid-descriptor', 'Static URL descriptor search must be an object.', {
+            path: ['search'],
+        });
+    }
+}
+function isRecord(input) {
+    return typeof input === 'object' && input !== null && !Array.isArray(input);
+}
+
+export { compileStaticHash, compileStaticSearch, compileStaticUrl };
+//# sourceMappingURL=static.js.map

package/dist/static.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"static.js","sources":["../src/static/compile-static-url.ts"],"sourcesContent":["import { UrlKitError } from '../errors/url-kit-error.js';\nimport type { NormalizedUrlDescriptor } from '../url/contracts.js';\nimport type {\n  CompileStaticUrlOptions,\n  StaticUrlDescriptor,\n  StaticUrlModeFromDescriptor,\n} from './contracts.js';\nimport { compilePath } from '../url/compile-path.js';\nimport { compileStaticHash } from './compile-static-hash.js';\nimport { compileStaticSearch } from './compile-static-search.js';\n\nexport function compileStaticUrl<Descriptor extends StaticUrlDescriptor>(\n  descriptor: Descriptor,\n  options: CompileStaticUrlOptions = {},\n): NormalizedUrlDescriptor<StaticUrlModeFromDescriptor<Descriptor>> {\n  assertStaticUrlDescriptor(descriptor);\n\n  const mode = Object.prototype.hasOwnProperty.call(descriptor, 'path') ? 'path' : 'pathless';\n  const normalized = {\n    mode,\n    pattern: mode === 'path' ? descriptor.path : undefined,\n    ...(mode === 'path' && descriptor.path !== undefined\n      ? {\n          path: compilePath(descriptor.path, {\n            params: 'parsed',\n            ...(options.pathConstraints ? { pathConstraints: options.pathConstraints } : {}),\n          }),\n        }\n      : {}),\n    ...(Object.prototype.hasOwnProperty.call(descriptor, 'search')\n      ? { search: compileStaticSearch(descriptor.search ?? {}) }\n      : {}),\n    ...(Object.prototype.hasOwnProperty.call(descriptor, 'hash') && descriptor.hash !== undefined\n      ? { hash: compileStaticHash(descriptor.hash) }\n      : {}),\n  } as NormalizedUrlDescriptor<StaticUrlModeFromDescriptor<Descriptor>>;\n\n  return Object.freeze(normalized);\n}\n\nfunction assertStaticUrlDescriptor(input: unknown): asserts input is StaticUrlDescriptor {\n  if (!isRecord(input)) {\n    throw new UrlKitError('invalid-descriptor', 'Static URL descriptor must be an object.', {\n      path: [],\n    });\n  }\n\n  if (Object.prototype.hasOwnProperty.call(input, 'path') && typeof input.path !== 'string') {\n    throw new UrlKitError('invalid-descriptor', 'Static URL descriptor path must be a string.', {\n      path: ['path'],\n    });\n  }\n\n  if (\n    Object.prototype.hasOwnProperty.call(input, 'search') &&\n    input.search !== undefined &&\n    !isRecord(input.search)\n  ) {\n    throw new UrlKitError('invalid-descriptor', 'Static URL descriptor search must be an object.', {\n      path: ['search'],\n    });\n  }\n}\n\nfunction isRecord(input: unknown): input is Record<string, unknown> {\n  return typeof input === 'object' && input !== null && !Array.isArray(input);\n}\n"],"names":[],"mappings":";;;;;;;SAWgB,gBAAgB,CAC9B,UAAsB,EACtB,UAAmC,EAAE,EAAA;IAErC,yBAAyB,CAAC,UAAU,CAAC;IAErC,MAAM,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG,MAAM,GAAG,UAAU;AAC3F,IAAA,MAAM,UAAU,GAAG;QACjB,IAAI;AACJ,QAAA,OAAO,EAAE,IAAI,KAAK,MAAM,GAAG,UAAU,CAAC,IAAI,GAAG,SAAS;QACtD,IAAI,IAAI,KAAK,MAAM,IAAI,UAAU,CAAC,IAAI,KAAK;AACzC,cAAE;AACE,gBAAA,IAAI,EAAE,WAAW,CAAC,UAAU,CAAC,IAAI,EAAE;AACjC,oBAAA,MAAM,EAAE,QAAQ;AAChB,oBAAA,IAAI,OAAO,CAAC,eAAe,GAAG,EAAE,eAAe,EAAE,OAAO,CAAC,eAAe,EAAE,GAAG,EAAE,CAAC;iBACjF,CAAC;AACH;cACD,EAAE,CAAC;AACP,QAAA,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ;AAC3D,cAAE,EAAE,MAAM,EAAE,mBAAmB,CAAC,UAAU,CAAC,MAAM,IAAI,EAAE,CAAC;cACtD,EAAE,CAAC;AACP,QAAA,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,UAAU,CAAC,IAAI,KAAK;cAChF,EAAE,IAAI,EAAE,iBAAiB,CAAC,UAAU,CAAC,IAAI,CAAC;cAC1C,EAAE,CAAC;KAC4D;AAErE,IAAA,OAAO,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC;AAClC;AAEA,SAAS,yBAAyB,CAAC,KAAc,EAAA;AAC/C,IAAA,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;AACpB,QAAA,MAAM,IAAI,WAAW,CAAC,oBAAoB,EAAE,0CAA0C,EAAE;AACtF,YAAA,IAAI,EAAE,EAAE;AACT,SAAA,CAAC;IACJ;IAEA,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE;AACzF,QAAA,MAAM,IAAI,WAAW,CAAC,oBAAoB,EAAE,8CAA8C,EAAE;YAC1F,IAAI,EAAE,CAAC,MAAM,CAAC;AACf,SAAA,CAAC;IACJ;IAEA,IACE,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC;QACrD,KAAK,CAAC,MAAM,KAAK,SAAS;AAC1B,QAAA,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,EACvB;AACA,QAAA,MAAM,IAAI,WAAW,CAAC,oBAAoB,EAAE,iDAAiD,EAAE;YAC7F,IAAI,EAAE,CAAC,QAAQ,CAAC;AACjB,SAAA,CAAC;IACJ;AACF;AAEA,SAAS,QAAQ,CAAC,KAAc,EAAA;AAC9B,IAAA,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;AAC7E;;;;"}

package/dist/url/assert-path-match-failure.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedPathSegment } from './path-segment.js';
+export declare function assertPathMatchFailure(pattern: string, pathname: string, segments: readonly ParsedPathSegment[]): never;

package/dist/url/build-compiled-url.d.ts

@@ -0,0 +1,3 @@
+import type { BuildUrlOptions, UrlBuildInput } from '../contracts.js';
+import type { CompiledUrlDescriptor } from './compile-url-descriptor.js';
+export declare function buildCompiledUrl<Mode extends 'path' | 'pathless', Params, Search, Hash, SearchInput = Partial<Search>, HashInput = Hash>(input: UrlBuildInput<Mode, Params, Search, Hash, SearchInput, HashInput>, compiled: CompiledUrlDescriptor<Mode>, options?: BuildUrlOptions): string;

package/dist/url/build-url.d.ts

@@ -0,0 +1,3 @@
+import type { BuildUrlOptions, UrlBuildInput, UrlMode } from '../contracts.js';
+import type { CompiledUrlDescriptor } from './compile-url-descriptor.js';
+export declare function buildUrl<Mode extends UrlMode, Params, Search, Hash>(input: UrlBuildInput<Mode, Params, Search, Hash>, compiled: CompiledUrlDescriptor<Mode>, options?: BuildUrlOptions): string;

package/dist/url/coerce-path-param.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedPathParamSegment } from './path-segment.js';
+export declare function coercePathParam(segment: ParsedPathParamSegment, value: string, paramsMode: 'raw' | 'parsed'): string | number;

package/dist/url/compile-path.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledPath, CompilePathOptions } from './contracts.js';
+export declare function compilePath<Pattern extends string>(pattern: Pattern, options?: CompilePathOptions): CompiledPath<Pattern>;

package/dist/url/compile-runtime-url-descriptor.d.ts

@@ -0,0 +1,2 @@
+import type { CreateUrlOptions, NormalizedUrlDescriptor, RuntimeUrlDescriptor, UrlModeFromRuntimeDescriptor } from './contracts.js';
+export declare function compileRuntimeUrlDescriptor<Descriptor extends RuntimeUrlDescriptor>(descriptor: Descriptor, options?: CreateUrlOptions): NormalizedUrlDescriptor<UrlModeFromRuntimeDescriptor<Descriptor>>;

package/dist/url/compile-url-descriptor.d.ts

@@ -0,0 +1,13 @@
+import type { CompiledHashDescriptor } from '../hash/contracts.js';
+import type { CompiledSearchSchema, RuntimeSearchSchema } from '../search/contracts.js';
+import type { UrlMode } from '../contracts.js';
+import type { CompiledPath, NormalizedUrlDescriptor } from './contracts.js';
+export interface CompiledUrlDescriptor<Mode extends UrlMode = UrlMode> {
+    readonly mode: Mode;
+    readonly pattern: Mode extends 'path' ? string : undefined;
+    readonly path: Mode extends 'path' ? CompiledPath : undefined;
+    readonly searchSchema?: RuntimeSearchSchema;
+    readonly search?: CompiledSearchSchema;
+    readonly hash?: CompiledHashDescriptor;
+}
+export declare function compileUrlDescriptor<Mode extends UrlMode>(descriptor: NormalizedUrlDescriptor<Mode>): CompiledUrlDescriptor<Mode>;

package/dist/url/contracts.d.ts

@@ -0,0 +1,91 @@
+import type { BuildHashArguments, BuildSearchOptions, BuildUrlOptions, EmptyParams, NormalizeUrlOptions, NormalizeUrlState, ParseRequestOptions, ParseUrlOptions, PatchSearchOptions, PathBuildMethod, PathConstraintMap, SearchInputArgument, UrlBuildInput, UrlMode, UrlNormalizeInput, UrlRequestInput, UrlSafeNormalizeResult, UrlSafeParseResult, UrlState, SearchArrayFormat, UnknownSearchBehavior } from '../contracts.js';
+import type { HashSchema, NormalizedHashDescriptor } from '../hash/contracts.js';
+import type { InferRuntimeSearch, InferRuntimeSearchBuildInput, RuntimeSearchSchema } from '../search/contracts.js';
+import type { InferRuntimeSchemaDescriptor, InferRuntimeSchemaValue } from '../schema/contracts.js';
+export interface NormalizedUrlDescriptor<Mode extends UrlMode = UrlMode> {
+    readonly mode: Mode;
+    readonly pattern: Mode extends 'path' ? string : undefined;
+    readonly path?: Mode extends 'path' ? CompiledPath : undefined;
+    readonly search?: RuntimeSearchSchema;
+    readonly hash?: NormalizedHashDescriptor;
+}
+export interface RuntimeUrlDescriptor {
+    readonly path?: string;
+    readonly search?: RuntimeSearchSchema;
+    readonly hash?: HashSchema;
+}
+export interface CreateUrlOptions {
+    readonly unknownSearch?: UnknownSearchBehavior;
+    readonly arrayFormat?: SearchArrayFormat;
+    readonly pathConstraints?: PathConstraintMap;
+}
+export interface CreateUrlContractOptions extends CreateUrlOptions {
+}
+export interface UrlContract<Mode extends UrlMode, Pathname, Params, Search, Hash, SearchInput = Partial<Search>, HashInput = Hash> {
+    readonly pattern: Mode extends 'path' ? string : undefined;
+    parse(input: string | URL, options?: ParseUrlOptions): UrlState<Pathname, Params, Search, Hash>;
+    safeParse(input: string | URL, options?: ParseUrlOptions): UrlSafeParseResult<Pathname, Params, Search, Hash>;
+    parseRequest(input: Request | UrlRequestInput, options?: ParseRequestOptions): UrlState<Pathname, Params, Search, Hash>;
+    safeParseRequest(input: Request | UrlRequestInput, options?: ParseRequestOptions): UrlSafeParseResult<Pathname, Params, Search, Hash>;
+    normalize<const Input extends UrlNormalizeInput<Mode, Params, Search, Hash, SearchInput, HashInput>>(input: Input & UrlNormalizeInput<Mode, Params, Search, Hash, SearchInput, HashInput>, options?: NormalizeUrlOptions): NormalizeUrlState<Mode, Pathname, Params, Search, Hash, Input>;
+    safeNormalize<const Input extends UrlNormalizeInput<Mode, Params, Search, Hash, SearchInput, HashInput>>(input: Input & UrlNormalizeInput<Mode, Params, Search, Hash, SearchInput, HashInput>, options?: NormalizeUrlOptions): UrlSafeNormalizeResult<Mode, Pathname, Params, Search, Hash, Input>;
+    build(input: UrlBuildInput<Mode, Params, Search, Hash, SearchInput, HashInput> | UrlState<Pathname, Params, Search, Hash>, options?: BuildUrlOptions): string;
+    match(input: string | URL, options?: ParseUrlOptions): boolean;
+    readonly parsePathname: Mode extends 'path' ? (pathname: string) => Params : never;
+    readonly buildPath: Mode extends 'path' ? PathBuildMethod<Params> : never;
+    parseSearch(input: string | URLSearchParams, options?: ParseUrlOptions): Search;
+    parseHash(input: unknown): Hash;
+    buildSearch(search: SearchInputArgument<SearchInput>, options?: BuildSearchOptions): string;
+    buildHash(...args: BuildHashArguments<HashInput>): string;
+    withSearch(input: string | URL, search: Partial<Search>, options?: PatchSearchOptions): string;
+    replaceSearch(input: string | URL, search: SearchInput, options?: BuildSearchOptions): string;
+    omitSearch(input: string | URL, keys: readonly string[], options?: BuildSearchOptions): string;
+    pickSearch(input: string | URL, keys: readonly string[], options?: BuildSearchOptions): string;
+}
+export interface CompilePathOptions {
+    readonly params?: 'raw' | 'parsed';
+    readonly pathConstraints?: PathConstraintMap;
+}
+export interface CompiledPath<Pattern extends string = string, Params = ParamsFromPattern<Pattern>> {
+    readonly pattern: Pattern;
+    parsePathname(pathname: string): Params;
+    buildPath: PathBuildMethod<Params>;
+}
+export type UrlModeFromRuntimeDescriptor<Descriptor> = Descriptor extends {
+    readonly path: string;
+} ? 'path' : 'pathless';
+export type PathnameFromRuntimeDescriptor<Descriptor> = Descriptor extends {
+    readonly path: infer Pattern extends string;
+} ? PathnameFromPattern<Pattern> : string;
+export type ParamsFromRuntimeDescriptor<Descriptor> = Descriptor extends {
+    readonly path: infer Pattern extends string;
+} ? ParamsFromPattern<Pattern> : EmptyParams;
+export type SearchFromRuntimeDescriptor<Descriptor> = Descriptor extends {
+    readonly search: infer Search extends RuntimeSearchSchema;
+} ? InferRuntimeSearch<Search> : EmptyParams;
+export type SearchBuildInputFromRuntimeDescriptor<Descriptor> = Descriptor extends {
+    readonly search: infer Search extends RuntimeSearchSchema;
+} ? InferRuntimeSearchBuildInput<Search> : EmptyParams;
+export type HashFromRuntimeDescriptor<Descriptor> = Descriptor extends {
+    readonly hash: infer Schema;
+} ? Schema extends HashSchema ? InferRuntimeSchemaValue<Schema> : never : undefined;
+export type HashBuildInputFromRuntimeDescriptor<Descriptor> = Descriptor extends {
+    readonly hash: infer Schema;
+} ? Schema extends HashSchema ? HashBuildInputFromRuntimeSchema<Schema> : never : undefined;
+export type HashBuildInputFromRuntimeSchema<Schema extends HashSchema> = InferRuntimeSchemaDescriptor<Schema> extends {
+    readonly presence: 'required';
+} ? InferRuntimeSchemaValue<Schema> : InferRuntimeSchemaValue<Schema> | undefined;
+export type RawParamsFromPattern<Pattern extends string> = Simplify<ExtractRawPathParams<Pattern>>;
+type ExtractRawPathParams<Pattern extends string> = Pattern extends `${string}{${infer Token}}${infer Rest}` ? RawParamFromToken<Token> & ExtractRawPathParams<Rest> : {};
+type RawParamFromToken<Token extends string> = Token extends `*${infer Name}` ? Readonly<Record<CleanPathParamName<Name>, string>> : Token extends `${infer Name}:${string}` ? Readonly<Record<CleanPathParamName<Name>, string>> : Readonly<Record<CleanPathParamName<Token>, string>>;
+export type PathnameFromPattern<Pattern extends string> = Pattern extends `${infer Before}{${infer Param}}${infer After}` ? `${Before}${PathParamValue<Param>}${PathnameFromPattern<After>}` : Pattern;
+export type ParamsFromPattern<Pattern extends string> = Simplify<ExtractPathParams<Pattern>>;
+type ExtractPathParams<Pattern extends string> = Pattern extends `${string}{${infer Token}}${infer Rest}` ? ParamFromToken<Token> & ExtractPathParams<Rest> : {};
+type ParamFromToken<Token extends string> = Token extends `*${infer Name}` ? Readonly<Record<CleanPathParamName<Name>, string>> : Token extends `${infer Name}:${infer Constraint}` ? Readonly<Record<CleanPathParamName<Name>, PathParamValueFromConstraint<Constraint>>> : Readonly<Record<CleanPathParamName<Token>, string>>;
+type CleanPathParamName<Name extends string> = Name extends `${infer Clean}?` ? Clean : Name;
+type PathParamValue<Param extends string> = Param extends `${string}:${infer Constraint}` ? PathParamValueFromConstraint<Constraint> : string;
+type PathParamValueFromConstraint<Constraint extends string> = Constraint extends 'int' ? number : Constraint extends 'number' ? number : Constraint extends `regex(${string})` ? string : string;
+type Simplify<Value> = {
+    readonly [Key in keyof Value]: Value[Key];
+} & {};
+export {};

package/dist/url/create-unsupported-url-method.d.ts

@@ -0,0 +1 @@
+export declare function createUnsupportedUrlMethod(name: string): (...args: readonly unknown[]) => never;

package/dist/url/create-url-contract.d.ts

@@ -0,0 +1,3 @@
+import type { EmptyParams } from '../contracts.js';
+import type { CreateUrlContractOptions, NormalizedUrlDescriptor, UrlContract } from './contracts.js';
+export declare function createUrlContract<Mode extends 'path' | 'pathless', Pathname = Mode extends 'path' ? string : string, Params = Mode extends 'path' ? Record<string, string | number> : EmptyParams, Search = Record<string, unknown>, Hash = string | undefined, SearchInput = Partial<Search>, HashInput = Hash>(descriptor: NormalizedUrlDescriptor<Mode>, options?: CreateUrlContractOptions): UrlContract<Mode, Pathname, Params, Search, Hash, SearchInput, HashInput>;

package/dist/url/create-url.d.ts

@@ -0,0 +1,2 @@
+import type { CreateUrlOptions, HashBuildInputFromRuntimeDescriptor, HashFromRuntimeDescriptor, ParamsFromRuntimeDescriptor, PathnameFromRuntimeDescriptor, RuntimeUrlDescriptor, SearchBuildInputFromRuntimeDescriptor, SearchFromRuntimeDescriptor, UrlContract, UrlModeFromRuntimeDescriptor } from './contracts.js';
+export declare function url<const Descriptor extends RuntimeUrlDescriptor>(descriptor: Descriptor, options?: CreateUrlOptions): UrlContract<UrlModeFromRuntimeDescriptor<Descriptor>, PathnameFromRuntimeDescriptor<Descriptor>, ParamsFromRuntimeDescriptor<Descriptor>, SearchFromRuntimeDescriptor<Descriptor>, HashFromRuntimeDescriptor<Descriptor>, SearchBuildInputFromRuntimeDescriptor<Descriptor>, HashBuildInputFromRuntimeDescriptor<Descriptor>>;

package/dist/url/filter-compiled-url-search.d.ts

@@ -0,0 +1,4 @@
+import type { BuildSearchOptions } from '../contracts.js';
+import type { CompiledUrlDescriptor } from './compile-url-descriptor.js';
+export declare function omitCompiledUrlSearch(input: string | URL, keys: readonly string[], _compiled: CompiledUrlDescriptor, options?: BuildSearchOptions): string;
+export declare function pickCompiledUrlSearch(input: string | URL, keys: readonly string[], _compiled: CompiledUrlDescriptor, options?: BuildSearchOptions): string;

package/dist/url/format-parsed-url.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedUrlInput } from './parse-url.js';
+export declare function formatParsedUrl(input: ParsedUrlInput, search: string): string;

package/dist/url/match-url.d.ts

@@ -0,0 +1,3 @@
+import type { ParseUrlOptions, UnknownSearchBehavior } from '../contracts.js';
+import type { CompiledUrlDescriptor } from './compile-url-descriptor.js';
+export declare function matchCompiledUrl(input: string | URL, compiled: CompiledUrlDescriptor, unknownSearch: UnknownSearchBehavior, options?: Pick<ParseUrlOptions, 'arrayFormat'>): boolean;

package/dist/url/normalize-compiled-url.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizeUrlState, UnknownSearchBehavior } from '../contracts.js';
+import type { CompiledUrlDescriptor } from './compile-url-descriptor.js';
+export declare function normalizeCompiledUrl<Mode extends 'path' | 'pathless', Pathname, Params, Search, Hash, Input>(input: Input, compiled: CompiledUrlDescriptor<Mode>, unknownSearch: UnknownSearchBehavior): NormalizeUrlState<Mode, Pathname, Params, Search, Hash, Input>;

package/dist/url/normalize-path-build-params.d.ts

@@ -0,0 +1 @@
+export declare function normalizePathBuildParams(params: unknown): Record<string, string | number | boolean>;

package/dist/url/normalize-url.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizeUrlState, UnknownSearchBehavior } from '../contracts.js';
+import type { CompiledUrlDescriptor } from './compile-url-descriptor.js';
+export declare function normalizeUrl<Mode extends 'path' | 'pathless', Pathname, Params, Search, Hash, Input>(input: Input, compiled: CompiledUrlDescriptor<Mode>, unknownSearch: UnknownSearchBehavior): NormalizeUrlState<Mode, Pathname, Params, Search, Hash, Input>;

package/dist/url/parse-compiled-url.d.ts

@@ -0,0 +1,3 @@
+import type { ParseUrlOptions, UrlState, UnknownSearchBehavior } from '../contracts.js';
+import type { CompiledUrlDescriptor } from './compile-url-descriptor.js';
+export declare function parseCompiledUrl<Pathname, Params, Search, Hash>(input: string | URL, compiled: CompiledUrlDescriptor, unknownSearch: UnknownSearchBehavior, options?: Pick<ParseUrlOptions, 'arrayFormat'>): UrlState<Pathname, Params, Search, Hash>;

package/dist/url/parse-path-pattern.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedPathSegment } from './path-segment.js';
+export declare function parsePathPattern(pattern: string): readonly ParsedPathSegment[];

package/dist/url/parse-request.d.ts

@@ -0,0 +1,2 @@
+import type { ParseRequestOptions, UrlRequestInput } from '../contracts.js';
+export declare function resolveRequestUrlInput(input: Request | UrlRequestInput, options?: ParseRequestOptions): string | URL;

package/dist/url/parse-url.d.ts

@@ -0,0 +1,6 @@
+export interface ParsedUrlInput {
+    readonly pathname: string;
+    readonly searchParams: URLSearchParams;
+    readonly hash: string;
+}
+export declare function parseUrl(input: string | URL): ParsedUrlInput;

package/dist/url/patch-compiled-url-search.d.ts

@@ -0,0 +1,3 @@
+import type { PatchSearchOptions } from '../contracts.js';
+import type { CompiledUrlDescriptor } from './compile-url-descriptor.js';
+export declare function patchCompiledUrlSearch(input: string | URL, patch: Record<string, unknown>, compiled: CompiledUrlDescriptor, options?: PatchSearchOptions): string;

package/dist/url/path-constraints.d.ts

@@ -0,0 +1,5 @@
+import type { ConstraintValidation } from '@cookbook/pathkit';
+import type { PathConstraintMap, RegisterPathConstraintOptions } from '../contracts.js';
+export declare function registerPathConstraint(name: string, constraint: ConstraintValidation, options?: RegisterPathConstraintOptions): void;
+export declare function registerPathConstraints(constraints: PathConstraintMap, options?: RegisterPathConstraintOptions): void;
+export declare function hasPathConstraint(name: string): boolean;

package/dist/url/path-param-kind.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedPathParamSegment } from './path-segment.js';
+export type PathParamKind = 'string' | 'int' | 'number' | 'regex';
+export declare function getPathParamKind(segment: ParsedPathParamSegment): PathParamKind;

package/dist/url/path-segment.d.ts

@@ -0,0 +1,11 @@
+export interface ParsedPathLiteralSegment {
+    readonly kind: 'literal';
+    readonly value: string;
+}
+export interface ParsedPathParamSegment {
+    readonly kind: 'param';
+    readonly name: string;
+    readonly constraint?: string;
+    readonly constraintParams?: string;
+}
+export type ParsedPathSegment = ParsedPathLiteralSegment | ParsedPathParamSegment;

package/dist/url/register-urlkit-path-constraints.d.ts

@@ -0,0 +1 @@
+export declare function registerUrlKitPathConstraints(): void;

package/dist/url/replace-compiled-url-search.d.ts

@@ -0,0 +1,3 @@
+import type { BuildSearchOptions } from '../contracts.js';
+import type { CompiledUrlDescriptor } from './compile-url-descriptor.js';
+export declare function replaceCompiledUrlSearch(input: string | URL, next: Record<string, unknown>, compiled: CompiledUrlDescriptor, options?: BuildSearchOptions): string;

package/dist/url/resolve-url-unknown-search.d.ts

@@ -0,0 +1,3 @@
+import type { UnknownSearchBehavior, UnknownSearchParams } from '../contracts.js';
+import type { RawSearchParams } from '../search/contracts.js';
+export declare function resolveUrlUnknownSearch(rawSearch: RawSearchParams, behavior: UnknownSearchBehavior): UnknownSearchParams | undefined;

package/dist/url/url-state-brand.d.ts

@@ -0,0 +1,7 @@
+declare const URL_STATE_BRAND: unique symbol;
+export interface BrandedUrlState {
+    readonly [URL_STATE_BRAND]: true;
+}
+export declare function markUrlState<State extends object>(state: State): State & BrandedUrlState;
+export declare function isUrlState(input: unknown): input is BrandedUrlState;
+export {};

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@cookbook/urlkit",
+  "version": "1.0.0",
+  "description": "Framework-agnostic typed URL contract library for parsing, validating, normalizing, matching, and building URL state.",
+  "license": "MIT",
+  "author": "The Cookbook",
+  "homepage": "https://github.com/the-cookbook/urlkit#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/the-cookbook/urlkit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/the-cookbook/urlkit/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./static": {
+      "types": "./dist/static.d.ts",
+      "import": "./dist/static.js"
+    },
+    "./router-runtime": {
+      "types": "./dist/router-runtime.d.ts",
+      "import": "./dist/router-runtime.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@changesets/cli": "^2.31.0",
+    "@commitlint/cli": "21.0.2",
+    "@commitlint/config-conventional": "21.0.2",
+    "@eslint/js": "10.0.1",
+    "@rollup/plugin-typescript": "^12.1.4",
+    "eslint": "10.4.1",
+    "eslint-config-prettier": "10.1.8",
+    "husky": "9.1.7",
+    "lint-staged": "17.0.7",
+    "prettier": "3.8.3",
+    "rollup": "^4.61.0",
+    "tslib": "^2.8.1",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "8.60.1",
+    "vitest": "^4.1.8"
+  },
+  "dependencies": {
+    "@cookbook/pathkit": "^0.2.1"
+  },
+  "scripts": {
+    "clean": "rm -rf dist coverage",
+    "build": "pnpm run clean && rollup -c && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "changeset": "changeset",
+    "version-package": "changeset version",
+    "release": "pnpm run typecheck && pnpm test && pnpm run build && changeset publish"
+  }
+}