324 lines
10 KiB
JavaScript
324 lines
10 KiB
JavaScript
"use strict";
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if (from && typeof from === "object" || typeof from === "function") {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
}
|
|
return to;
|
|
};
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
|
|
// src/index.ts
|
|
var src_exports = {};
|
|
__export(src_exports, {
|
|
RequestCookies: () => RequestCookies,
|
|
ResponseCookies: () => ResponseCookies,
|
|
parseCookie: () => parseCookie,
|
|
parseSetCookie: () => parseSetCookie,
|
|
splitCookiesString: () => splitCookiesString,
|
|
stringifyCookie: () => stringifyCookie
|
|
});
|
|
module.exports = __toCommonJS(src_exports);
|
|
|
|
// src/serialize.ts
|
|
function stringifyCookie(c) {
|
|
var _a;
|
|
const attrs = [
|
|
"path" in c && c.path && `Path=${c.path}`,
|
|
"expires" in c && (c.expires || c.expires === 0) && `Expires=${(typeof c.expires === "number" ? new Date(c.expires) : c.expires).toUTCString()}`,
|
|
"maxAge" in c && typeof c.maxAge === "number" && `Max-Age=${c.maxAge}`,
|
|
"domain" in c && c.domain && `Domain=${c.domain}`,
|
|
"secure" in c && c.secure && "Secure",
|
|
"httpOnly" in c && c.httpOnly && "HttpOnly",
|
|
"sameSite" in c && c.sameSite && `SameSite=${c.sameSite}`
|
|
].filter(Boolean);
|
|
return `${c.name}=${encodeURIComponent((_a = c.value) != null ? _a : "")}; ${attrs.join("; ")}`;
|
|
}
|
|
function parseCookie(cookie) {
|
|
const map = /* @__PURE__ */ new Map();
|
|
for (const pair of cookie.split(/; */)) {
|
|
if (!pair)
|
|
continue;
|
|
const splitAt = pair.indexOf("=");
|
|
if (splitAt === -1) {
|
|
map.set(pair, "true");
|
|
continue;
|
|
}
|
|
const [key, value] = [pair.slice(0, splitAt), pair.slice(splitAt + 1)];
|
|
try {
|
|
map.set(key, decodeURIComponent(value != null ? value : "true"));
|
|
} catch {
|
|
}
|
|
}
|
|
return map;
|
|
}
|
|
function parseSetCookie(setCookie) {
|
|
if (!setCookie) {
|
|
return void 0;
|
|
}
|
|
const [[name, value], ...attributes] = parseCookie(setCookie);
|
|
const { domain, expires, httponly, maxage, path, samesite, secure } = Object.fromEntries(
|
|
attributes.map(([key, value2]) => [key.toLowerCase(), value2])
|
|
);
|
|
const cookie = {
|
|
name,
|
|
value: decodeURIComponent(value),
|
|
domain,
|
|
...expires && { expires: new Date(expires) },
|
|
...httponly && { httpOnly: true },
|
|
...typeof maxage === "string" && { maxAge: Number(maxage) },
|
|
path,
|
|
...samesite && { sameSite: parseSameSite(samesite) },
|
|
...secure && { secure: true }
|
|
};
|
|
return compact(cookie);
|
|
}
|
|
function compact(t) {
|
|
const newT = {};
|
|
for (const key in t) {
|
|
if (t[key]) {
|
|
newT[key] = t[key];
|
|
}
|
|
}
|
|
return newT;
|
|
}
|
|
var SAME_SITE = ["strict", "lax", "none"];
|
|
function parseSameSite(string) {
|
|
string = string.toLowerCase();
|
|
return SAME_SITE.includes(string) ? string : void 0;
|
|
}
|
|
function splitCookiesString(cookiesString) {
|
|
if (!cookiesString)
|
|
return [];
|
|
var cookiesStrings = [];
|
|
var pos = 0;
|
|
var start;
|
|
var ch;
|
|
var lastComma;
|
|
var nextStart;
|
|
var cookiesSeparatorFound;
|
|
function skipWhitespace() {
|
|
while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
|
|
pos += 1;
|
|
}
|
|
return pos < cookiesString.length;
|
|
}
|
|
function notSpecialChar() {
|
|
ch = cookiesString.charAt(pos);
|
|
return ch !== "=" && ch !== ";" && ch !== ",";
|
|
}
|
|
while (pos < cookiesString.length) {
|
|
start = pos;
|
|
cookiesSeparatorFound = false;
|
|
while (skipWhitespace()) {
|
|
ch = cookiesString.charAt(pos);
|
|
if (ch === ",") {
|
|
lastComma = pos;
|
|
pos += 1;
|
|
skipWhitespace();
|
|
nextStart = pos;
|
|
while (pos < cookiesString.length && notSpecialChar()) {
|
|
pos += 1;
|
|
}
|
|
if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
|
|
cookiesSeparatorFound = true;
|
|
pos = nextStart;
|
|
cookiesStrings.push(cookiesString.substring(start, lastComma));
|
|
start = pos;
|
|
} else {
|
|
pos = lastComma + 1;
|
|
}
|
|
} else {
|
|
pos += 1;
|
|
}
|
|
}
|
|
if (!cookiesSeparatorFound || pos >= cookiesString.length) {
|
|
cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
|
|
}
|
|
}
|
|
return cookiesStrings;
|
|
}
|
|
|
|
// src/request-cookies.ts
|
|
var RequestCookies = class {
|
|
constructor(requestHeaders) {
|
|
/** @internal */
|
|
this._parsed = /* @__PURE__ */ new Map();
|
|
this._headers = requestHeaders;
|
|
const header = requestHeaders.get("cookie");
|
|
if (header) {
|
|
const parsed = parseCookie(header);
|
|
for (const [name, value] of parsed) {
|
|
this._parsed.set(name, { name, value });
|
|
}
|
|
}
|
|
}
|
|
[Symbol.iterator]() {
|
|
return this._parsed[Symbol.iterator]();
|
|
}
|
|
/**
|
|
* The amount of cookies received from the client
|
|
*/
|
|
get size() {
|
|
return this._parsed.size;
|
|
}
|
|
get(...args) {
|
|
const name = typeof args[0] === "string" ? args[0] : args[0].name;
|
|
return this._parsed.get(name);
|
|
}
|
|
getAll(...args) {
|
|
var _a;
|
|
const all = Array.from(this._parsed);
|
|
if (!args.length) {
|
|
return all.map(([_, value]) => value);
|
|
}
|
|
const name = typeof args[0] === "string" ? args[0] : (_a = args[0]) == null ? void 0 : _a.name;
|
|
return all.filter(([n]) => n === name).map(([_, value]) => value);
|
|
}
|
|
has(name) {
|
|
return this._parsed.has(name);
|
|
}
|
|
set(...args) {
|
|
const [name, value] = args.length === 1 ? [args[0].name, args[0].value] : args;
|
|
const map = this._parsed;
|
|
map.set(name, { name, value });
|
|
this._headers.set(
|
|
"cookie",
|
|
Array.from(map).map(([_, value2]) => stringifyCookie(value2)).join("; ")
|
|
);
|
|
return this;
|
|
}
|
|
/**
|
|
* Delete the cookies matching the passed name or names in the request.
|
|
*/
|
|
delete(names) {
|
|
const map = this._parsed;
|
|
const result = !Array.isArray(names) ? map.delete(names) : names.map((name) => map.delete(name));
|
|
this._headers.set(
|
|
"cookie",
|
|
Array.from(map).map(([_, value]) => stringifyCookie(value)).join("; ")
|
|
);
|
|
return result;
|
|
}
|
|
/**
|
|
* Delete all the cookies in the cookies in the request.
|
|
*/
|
|
clear() {
|
|
this.delete(Array.from(this._parsed.keys()));
|
|
return this;
|
|
}
|
|
/**
|
|
* Format the cookies in the request as a string for logging
|
|
*/
|
|
[Symbol.for("edge-runtime.inspect.custom")]() {
|
|
return `RequestCookies ${JSON.stringify(Object.fromEntries(this._parsed))}`;
|
|
}
|
|
toString() {
|
|
return [...this._parsed.values()].map((v) => `${v.name}=${encodeURIComponent(v.value)}`).join("; ");
|
|
}
|
|
};
|
|
|
|
// src/response-cookies.ts
|
|
var ResponseCookies = class {
|
|
constructor(responseHeaders) {
|
|
/** @internal */
|
|
this._parsed = /* @__PURE__ */ new Map();
|
|
var _a, _b;
|
|
this._headers = responseHeaders;
|
|
const setCookie = (_a = responseHeaders.getSetCookie) == null ? void 0 : _a.call(responseHeaders);
|
|
(_b = responseHeaders.get("set-cookie")) != null ? _b : [];
|
|
const cookieStrings = Array.isArray(setCookie) ? setCookie : (
|
|
// TODO: remove splitCookiesString when `getSetCookie` adoption is high enough in Node.js
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/Headers/getSetCookie#browser_compatibility
|
|
splitCookiesString(setCookie)
|
|
);
|
|
for (const cookieString of cookieStrings) {
|
|
const parsed = parseSetCookie(cookieString);
|
|
if (parsed)
|
|
this._parsed.set(parsed.name, parsed);
|
|
}
|
|
}
|
|
/**
|
|
* {@link https://wicg.github.io/cookie-store/#CookieStore-get CookieStore#get} without the Promise.
|
|
*/
|
|
get(...args) {
|
|
const key = typeof args[0] === "string" ? args[0] : args[0].name;
|
|
return this._parsed.get(key);
|
|
}
|
|
/**
|
|
* {@link https://wicg.github.io/cookie-store/#CookieStore-getAll CookieStore#getAll} without the Promise.
|
|
*/
|
|
getAll(...args) {
|
|
var _a;
|
|
const all = Array.from(this._parsed.values());
|
|
if (!args.length) {
|
|
return all;
|
|
}
|
|
const key = typeof args[0] === "string" ? args[0] : (_a = args[0]) == null ? void 0 : _a.name;
|
|
return all.filter((c) => c.name === key);
|
|
}
|
|
has(name) {
|
|
return this._parsed.has(name);
|
|
}
|
|
/**
|
|
* {@link https://wicg.github.io/cookie-store/#CookieStore-set CookieStore#set} without the Promise.
|
|
*/
|
|
set(...args) {
|
|
const [name, value, cookie] = args.length === 1 ? [args[0].name, args[0].value, args[0]] : args;
|
|
const map = this._parsed;
|
|
map.set(name, normalizeCookie({ name, value, ...cookie }));
|
|
replace(map, this._headers);
|
|
return this;
|
|
}
|
|
/**
|
|
* {@link https://wicg.github.io/cookie-store/#CookieStore-delete CookieStore#delete} without the Promise.
|
|
*/
|
|
delete(...args) {
|
|
const [name, path, domain] = typeof args[0] === "string" ? [args[0]] : [args[0].name, args[0].path, args[0].domain];
|
|
return this.set({ name, path, domain, value: "", expires: /* @__PURE__ */ new Date(0) });
|
|
}
|
|
[Symbol.for("edge-runtime.inspect.custom")]() {
|
|
return `ResponseCookies ${JSON.stringify(Object.fromEntries(this._parsed))}`;
|
|
}
|
|
toString() {
|
|
return [...this._parsed.values()].map(stringifyCookie).join("; ");
|
|
}
|
|
};
|
|
function replace(bag, headers) {
|
|
headers.delete("set-cookie");
|
|
for (const [, value] of bag) {
|
|
const serialized = stringifyCookie(value);
|
|
headers.append("set-cookie", serialized);
|
|
}
|
|
}
|
|
function normalizeCookie(cookie = { name: "", value: "" }) {
|
|
if (typeof cookie.expires === "number") {
|
|
cookie.expires = new Date(cookie.expires);
|
|
}
|
|
if (cookie.maxAge) {
|
|
cookie.expires = new Date(Date.now() + cookie.maxAge * 1e3);
|
|
}
|
|
if (cookie.path === null || cookie.path === void 0) {
|
|
cookie.path = "/";
|
|
}
|
|
return cookie;
|
|
}
|
|
// Annotate the CommonJS export names for ESM import in node:
|
|
0 && (module.exports = {
|
|
RequestCookies,
|
|
ResponseCookies,
|
|
parseCookie,
|
|
parseSetCookie,
|
|
splitCookiesString,
|
|
stringifyCookie
|
|
});
|