// Hardcoded module "node:dns"
// only resolve4, resolve, lookup, resolve6 and resolveSrv are implemented.
const { dns } = globalThis.Bun;
function lookup(domain, options, callback) {
if (typeof options == "function") {
callback = options;
}
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
if (typeof options == "number") {
options = { family: options };
}
dns.lookup(domain, options).then(
res => {
res.sort((a, b) => a.family - b.family);
if (options?.all) {
callback(null, res.map(mapLookupAll));
} else {
const [{ address, family }] = res;
callback(null, address, family);
}
},
error => {
callback(error);
},
);
}
function resolveSrv(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolveSrv(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
function resolveTxt(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolveTxt(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
function resolveSoa(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolveSoa(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
function resolveNaptr(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolveNaptr(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
function resolveMx(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolveMx(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
function resolveCaa(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolveCaa(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
function resolveNs(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolveNs(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
function resolvePtr(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolvePtr(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
function resolveCname(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolveCname(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
function lookupService(address, port, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
callback(null, address, port);
}
var InternalResolver = class Resolver {
constructor(options) {}
cancel() {}
getServers() {
return [];
}
resolve(hostname, rrtype, callback) {
if (typeof rrtype == "function") {
callback = rrtype;
rrtype = null;
}
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolve(hostname).then(
results => {
switch (rrtype?.toLowerCase()) {
case "a":
case "aaaa":
callback(null, hostname, results.map(mapResolveX));
break;
default:
callback(null, results);
break;
}
},
error => {
callback(error);
},
);
}
resolve4(hostname, options, callback) {
if (typeof options == "function") {
callback = options;
options = null;
}
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.lookup(hostname, { family: 4 }).then(
addresses => {
callback(null, options?.ttl ? addresses : addresses.map(mapResolveX));
},
error => {
callback(error);
},
);
}
resolve6(hostname, options, callback) {
if (typeof options == "function") {
callback = options;
options = null;
}
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.lookup(hostname, { family: 6 }).then(
addresses => {
callback(null, options?.ttl ? addresses : addresses.map(({ address }) => address));
},
error => {
callback(error);
},
);
}
resolveAny(hostname, callback) {
callback(null, []);
}
resolveCname(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolveCname(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
resolveMx(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolveMx(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
resolveNaptr(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolveNaptr(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
resolveNs(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolveNs(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
resolvePtr(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolvePtr(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
resolveSrv(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolveSrv(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
resolveCaa(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolveCaa(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
resolveTxt(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolveTxt(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
resolveSoa(hostname, callback) {
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolveSoa(hostname, callback).then(
results => {
callback(null, results);
},
error => {
callback(error);
},
);
}
reverse(ip, callback) {
callback(null, []);
}
setServers(servers) {}
};
function resolve(hostname, rrtype, callback) {
if (typeof rrtype == "function") {
callback = rrtype;
}
if (typeof callback != "function") {
throw new TypeError("callback must be a function");
}
dns.resolve(hostname).then(
results => {
switch (rrtype?.toLowerCase()) {
case "a":
case "aaaa":
callback(
null,
hostname,
results.map(({ address }) => address),
);
break;
default:
callback(null, results);
break;
}
},
error => {
callback(error);
},
);
}
function Resolver(options) {
return new InternalResolver(options);
}
Object.setPrototypeOf(Resolver.prototype, InternalResolver.prototype);
Object.setPrototypeOf(Resolver, InternalResolver);
export var {
resolve,
resolve4,
resolve6,
resolveAny,
resolveCname,
resolveCaa,
resolveMx,
resolveNaptr,
resolveNs,
resolvePtr,
resolveSoa,
resolveSrv,
reverse,
resolveTxt,
} = InternalResolver.prototype;
function setDefaultResultOrder() {}
function setServers() {}
const promisifyLookup = res => {
res.sort((a, b) => a.family - b.family);
const [{ address, family }] = res;
return { address, family };
};
const mapLookupAll = res => {
const { address, family } = res;
return { address, family };
};
const promisifyLookupAll = res => {
res.sort((a, b) => a.family - b.family);
return res.map(mapLookupAll);
};
const mapResolveX = a => a.address;
const promisifyResolveX = res => {
return res?.map(mapResolveX);
};
// promisified versions
export const promises = {
lookup(domain, options) {
if (options?.all) {
return dns.lookup(domain, options).then(promisifyLookupAll);
}
return dns.lookup(domain, options).then(promisifyLookup);
},
lookupService(address, port) {
return Promise.resolve([]);
},
resolve(hostname, rrtype) {
if (typeof rrtype !== "string") {
rrtype = null;
}
switch (rrtype?.toLowerCase()) {
case "a":
case "aaaa":
return dns.resolve(hostname, rrtype).then(promisifyLookup);
default:
return dns.resolve(hostname, rrtype);
}
},
resolve4(hostname, options) {
if (options?.ttl) {
return dns.lookup(hostname, { family: 4 });
}
return dns.lookup(hostname, { family: 4 }).then(promisifyResolveX);
},
resolve6(hostname, options) {
if (options?.ttl) {
return dns.lookup(hostname, { family: 6 });
}
return dns.lookup(hostname, { family: 6 }).then(promisifyResolveX);
},
resolveSrv(hostname) {
return dns.resolveSrv(hostname);
},
resolveTxt(hostname) {
return dns.resolveTxt(hostname);
},
resolveSoa(hostname) {
return dns.resolveSoa(hostname);
},
resolveNaptr(hostname) {
return dns.resolveNaptr(hostname);
},
resolveMx(hostname) {
return dns.resolveMx(hostname);
},
resolveCaa(hostname) {
return dns.resolveCaa(hostname);
},
resolveNs(hostname) {
return dns.resolveNs(hostname);
},
resolvePtr(hostname) {
return dns.resolvePtr(hostname);
},
resolveCname(hostname) {
return dns.resolveCname(hostname);
},
Resolver: class Resolver {
constructor(options) {}
cancel() {}
getServers() {
return [];
}
resolve(hostname, rrtype) {
if (typeof rrtype !== "string") {
rrtype = null;
}
switch (rrtype?.toLowerCase()) {
case "a":
case "aaaa":
return dns.resolve(hostname, rrtype).then(promisifyLookup);
default:
return dns.resolve(hostname, rrtype);
}
}
resolve4(hostname, options) {
if (options?.ttl) {
return dns.lookup(hostname, { family: 4 });
}
return dns.lookup(hostname, { family: 4 }).then(promisifyResolveX);
}
resolve6(hostname, options) {
if (options?.ttl) {
return dns.lookup(hostname, { family: 6 });
}
return dns.lookup(hostname, { family: 6 }).then(promisifyResolveX);
}
resolveAny(hostname) {
return Promise.resolve([]);
}
resolveCname(hostname) {
return dns.resolveCname(hostname);
}
resolveMx(hostname) {
return dns.resolveMx(hostname);
}
resolveNaptr(hostname) {
return dns.resolveNaptr(hostname);
}
resolveNs(hostname) {
return dns.resolveNs(hostname);
}
resolvePtr(hostname) {
return dns.resolvePtr(hostname);
}
resolveSoa(hostname) {
return dns.resolveSoa(hostname);
}
resolveSrv(hostname) {
return dns.resolveSrv(hostname);
}
resolveCaa(hostname) {
return dns.resolveCaa(hostname);
}
resolveTxt(hostname) {
return dns.resolveTxt(hostname);
}
reverse(ip) {
return Promise.resolve([]);
}
setServers(servers) {}
},
};
for (const key of ["resolveAny", "reverse"]) {
promises[key] = () => Promise.resolve(undefined);
}
const exports = {
// these are wrong
ADDRCONFIG: 0,
ALL: 1,
V4MAPPED: 2,
// ERROR CODES
NODATA: "DNS_ENODATA",
FORMERR: "DNS_EFORMERR",
SERVFAIL: "DNS_ESERVFAIL",
NOTFOUND: "DNS_ENOTFOUND",
NOTIMP: "DNS_ENOTIMP",
REFUSED: "DNS_EREFUSED",
BADQUERY: "DNS_EBADQUERY",
BADNAME: "DNS_EBADNAME",
BADFAMILY: "DNS_EBADFAMILY",
BADRESP: "DNS_EBADRESP",
CONNREFUSED: "DNS_ECONNREFUSED",
TIMEOUT: "DNS_ETIMEOUT",
EOF: "DNS_EEOF",
FILE: "DNS_EFILE",
NOMEM: "DNS_ENOMEM",
DESTRUCTION: "DNS_EDESTRUCTION",
BADSTR: "DNS_EBADSTR",
BADFLAGS: "DNS_EBADFLAGS",
NONAME: "DNS_ENONAME",
BADHINTS: "DNS_EBADHINTS",
NOTINITIALIZED: "DNS_ENOTINITIALIZED",
LOADIPHLPAPI: "DNS_ELOADIPHLPAPI",
ADDRGETNETWORKPARAMS: "DNS_EADDRGETNETWORKPARAMS",
CANCELLED: "DNS_ECANCELLED",
lookup,
lookupService,
Resolver,
setServers,
setDefaultResultOrder,
resolve,
reverse,
resolve4,
resolve6,
resolveAny,
resolveCname,
resolveCaa,
resolveMx,
resolveNs,
resolvePtr,
resolveSoa,
resolveSrv,
resolveTxt,
resolveNaptr,
promises,
[Symbol.for("CommonJS")]: 0,
};
export default exports;
export const {
ADDRCONFIG,
ALL,
V4MAPPED,
NODATA,
FORMERR,
SERVFAIL,
NOTFOUND,
NOTIMP,
REFUSED,
BADQUERY,
BADNAME,
BADFAMILY,
BADRESP,
CONNREFUSED,
TIMEOUT,
EOF,
FILE,
NOMEM,
DESTRUCTION,
BADSTR,
BADFLAGS,
NONAME,
BADHINTS,
NOTINITIALIZED,
LOADIPHLPAPI,
ADDRGETNETWORKPARAMS,
CANCELLED,
} = exports;
export { lookup, lookupService, Resolver, setServers, setDefaultResultOrder };
option>
| Unnamed repository; edit this file 'description' to name the repository. | |
| Age | Commit message (Collapse) | Author | Files | Lines |
|
* improve CI times
* improve CI times
|
|
|
|
|
|
* feat: first pass at MDX support
* fix: move built-in JSX renderer to come first
* chore: remove jsx example
* chore: update lockfile
* chore: cleanup example
* fix: missing deps
* refactor: move component render logic to `renderPage`
* chore: update HMR script
* chore: update MDX example
* refactor: prefer unshit
* refactor: remove TODO comment
* fix: remove duplicate identifier
* refactor: cleanup mdx entrypoint
* fix: better html handling
* fix: add tsconfig to mdx package
* chore: update lockfile
* fix: do not sort plugins unless mdx is enabled
* chore: update compiler
* fix(hmr): maybe render head for non-Astro pages
* fix: set initial pageExtensions
* refactor: cleanup addPageExtension
* refactor: remove addPageExtensions from types
* refactor: expose HookParameters type
* fix: only default to astro for MDX
* test: pick up jsx support in test fixtures
* refactor: simplify mdx entrypoint
* test: add basic MDX tests
* test(e2e): add mdx + framework tests
* chore: update lockfile
* test(e2e): fix preact mdx e2e test
* fix(mdx): disable .md support
* test(e2e): fix vue-component test missing mdx
* test(e2e): fix solid component needing import
* fix: allow `client:only="solid"` as an alias to `solid-js`
* chore: move to with-mdx example
* chore: update MDX readme
* chore: update example readme
* chore: bump astro version
* chore: update lockfile
* Update mod.d.ts
* feat: support `export const components` in MDX pages
* chore: update mdx example
* fix: update jsx-runtime with better slot support
* refactor: remove object style support
* chore: cleanup package exports
* chore: add todo comment
* refactor: improve isPage function, move to utils
* refactor: dry up manual HMR updates
* chore: add dev tests for MDX
* chore: prefer set to array
* chore: add changesets
* fix(hmr): flip public/private route
Co-authored-by: Nate Moore <nate@astro.build>
|
|
|
|
Co-authored-by: FredKSchott <FredKSchott@users.noreply.github.com>
|
|
* sitemap readme skeleton + first sections
* Revert "sitemap readme skeleton + first sections"
This reverts commit cc55b312b6dc95522645002806d63f32c33d1956.
* sitemap readme skeleton + first sections
* remove canonicalURL option from sitemap
* add customPages option to readme
* sitemap examples
* partytown
* deno run command
* reference deno example
* node readme
* netlify & vercel readmes
* note that telemetry is installed
* telemetry is *enabled*, not installed
* Update packages/integrations/vercel/README.md
Co-authored-by: Chris Swithinbank <swithinbank@gmail.com>
* Update packages/integrations/vercel/README.md
Co-authored-by: Chris Swithinbank <swithinbank@gmail.com>
* readme -> README
* Update packages/integrations/deno/readme.md
Co-authored-by: Chris Swithinbank <swithinbank@gmail.com>
* Update packages/integrations/deno/readme.md
Co-authored-by: Chris Swithinbank <swithinbank@gmail.com>
* qualify they
* Update packages/integrations/sitemap/README.md
Co-authored-by: Chris Swithinbank <swithinbank@gmail.com>
* Uppercase README names
* Update packages/integrations/partytown/README.md
Co-authored-by: Chris Swithinbank <swithinbank@gmail.com>
* imports -> import typo
* update changeset
Co-authored-by: Chris Swithinbank <swithinbank@gmail.com>
|
|
|
|
|
|
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
|
|
|
|
|
|
* Fix "Invalid hook call" warning
* Fix eslint warnings
* Apply code review suggestions
|
|
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
|
|
|
|
* lockfile update
* update lockfile gen script
* Update index.ts
|
|
|