@volter/world-core 3.0.18 → 3.0.19

package/vendor-hosts.cjs

@@ -55,6 +55,39 @@ const COMPILED = new Map();
 /** The hand table's keys, before any pack's rules: a pack installed later replaces its hand entry in place (keeping its
  *  position, which decides who answers a shared host first), where the built-in facts may not declare one twice. */
 const HAND = new Set(Object.keys(VENDOR_HOSTS));
+/** One host rule as a predicate over (hostname, pathname?): its one selector (host | suffix | hostPattern) and its
+ *  pathPattern, a path left out matching any. */
+function compileHostRule(rule, where) {
+  const selectors = ['host', 'suffix', 'hostPattern'].filter((k) => rule[k] !== undefined).length;
+  if (selectors !== 1) throw new Error(`inject: ${where} rule ${JSON.stringify(rule)} — exactly one of host | suffix | hostPattern (pack-facts.json is hand-edited or stale)`);
+  const hostRe = rule.hostPattern === undefined ? null : new RegExp(rule.hostPattern);
+  const pathRe = rule.pathPattern === undefined ? null : new RegExp(rule.pathPattern);
+  return (h, p) =>
+    (rule.host !== undefined ? h === rule.host : rule.suffix !== undefined ? h.endsWith(rule.suffix) : hostRe.test(h))
+    && (pathRe === null || p === undefined || pathRe.test(p));
+}
+
+/** A pack's host rules (its descriptor's `hosts`) read as the injector reads them: `names(host)`, whether any include
+ *  rule's selector names the host, whatever the path; `takes(host, path)`, whether the request is the pack's (under
+ *  one of its keys, an include matches and no exclude does). The content route at a World's place holds a
+ *  `<base>/@<host>/<path>` to it (pack-fetch.ts). */
+function hostRules(rules) {
+  const byKey = new Map();
+  for (const rule of rules || []) {
+    const key = rule.key === undefined ? '' : rule.key;
+    if (!byKey.has(key)) byKey.set(key, []);
+    byKey.get(key).push(rule);
+  }
+  const keys = [...byKey.values()].map((keyRules) => ({
+    includes: keyRules.filter((r) => r.exclude !== true).map((r) => compileHostRule(r, 'a pack')),
+    excludes: keyRules.filter((r) => r.exclude === true).map((r) => compileHostRule(r, 'a pack')),
+  }));
+  return {
+    names: (h) => keys.some((k) => k.includes.some((m) => m(h))),
+    takes: (h, p) => keys.some((k) => k.includes.some((m) => m(h, p)) && !k.excludes.some((m) => m(h, p))),
+  };
+}
+
 function compilePackHosts(packs, overlay) {
   for (const vendor of Object.keys(packs)) {
     const rules = packs[vendor].hosts;
@@ -77,15 +110,7 @@ function compilePackHosts(packs, overlay) {
       if (VENDOR_HOSTS[key] && !(overlay && HAND.has(key))) {
         throw new Error(`inject: key "${key}" (pack ${vendor}) is declared twice — on this descriptor and in the hand VENDOR_HOSTS table or another pack's descriptor; a key has one home.`);
       }
-      const compile = (rule) => {
-        const selectors = ['host', 'suffix', 'hostPattern'].filter((k) => rule[k] !== undefined).length;
-        if (selectors !== 1) throw new Error(`inject: key "${key}" (pack ${vendor}) rule ${JSON.stringify(rule)} — exactly one of host | suffix | hostPattern (pack-facts.json is hand-edited or stale)`);
-        const hostRe = rule.hostPattern === undefined ? null : new RegExp(rule.hostPattern);
-        const pathRe = rule.pathPattern === undefined ? null : new RegExp(rule.pathPattern);
-        return (h, p) =>
-          (rule.host !== undefined ? h === rule.host : rule.suffix !== undefined ? h.endsWith(rule.suffix) : hostRe.test(h))
-          && (pathRe === null || p === undefined || pathRe.test(p));
-      };
+      const compile = (rule) => compileHostRule(rule, `key "${key}" (pack ${vendor})`);
       const includes = keyRules.filter((r) => r.exclude !== true).map(compile);
       const excludes = keyRules.filter((r) => r.exclude === true).map(compile);
       VENDOR_HOSTS[key] = (h, p) => includes.some((m) => m(h, p)) && !excludes.some((m) => m(h, p));
@@ -141,4 +166,4 @@ function twinOrigins(env) {
   return map;
 }
 
-module.exports = { VENDOR_HOSTS, addPackHosts, isVendorHost, vendorsOfHost, twinEnvStem, twinOrigins };
+module.exports = { VENDOR_HOSTS, hostRules, addPackHosts, isVendorHost, vendorsOfHost, twinEnvStem, twinOrigins };

package/vendor-hosts.d.cts

@@ -6,3 +6,6 @@ export function vendorsOfHost(hostname: string): string[];
 export function twinEnvStem(vendor: string): string;
 /** The vendors whose twin `env` points at, each with its origin. */
 export function twinOrigins(env: Readonly<Record<string, string | undefined>>): Record<string, string>;
+/** A pack's host rules (its descriptor's `hosts`, as data) read as the injector reads them: whether any include names a
+ *  host whatever the path, and whether a request to a host and path is the pack's. */
+export function hostRules(rules: ReadonlyArray<{ host?: string; suffix?: string; hostPattern?: string; pathPattern?: string; key?: string; exclude?: true }> | undefined): { names(hostname: string): boolean; takes(hostname: string, pathname: string): boolean };