@egildo/provenance 0.0.0-stage → 0.7.0

package/dist/resolvers.js

@@ -0,0 +1,42 @@
+// The shipped resolvers, chosen by request scheme (specs/source-graph-kernel/research.md, Resolution).
+export const hasScheme = (request) => /^[a-z][a-z0-9+.-]*:/i.test(request);
+const isWeb = (url) => /^https?:/i.test(url);
+/** `data:`, an empty request, and a request that is only a fragment make no edge. */
+const none = {
+    claims: request => request === "" || request.startsWith("#") || /^data:/i.test(request),
+    resolve: async () => null,
+};
+/** `http(s):` and `//host/…` are external leaves, never read. */
+const external = {
+    claims: request => isWeb(request) || request.startsWith("//"),
+    resolve: async (request) => ({ external: request.startsWith("//") ? `https:${request}` : request }),
+};
+/**
+ * A path relative to `base`, a directory location. Query and fragment are dropped and the path is
+ * percent-decoded. The one location computed is the probe; the host saying nothing is there
+ * leaves the edge unresolved. A web `base` (an HTML `<base href="https://…">`) makes it external.
+ */
+const relative = {
+    claims: request => !hasScheme(request) && !request.startsWith("/"),
+    async resolve(request, base, host) {
+        if (isWeb(base))
+            return { external: new URL(request, base).href };
+        const path = request.replace(/[?#].*$/s, "");
+        let decoded = path;
+        try {
+            decoded = decodeURIComponent(path);
+        }
+        catch {
+            // A malformed escape stays as written.
+        }
+        const location = host.paths.resolve(base, decoded);
+        const target = await host.canonicalize(location);
+        return target === undefined ? { probes: [location] } : { probes: [location], target };
+    },
+};
+const shipped = [none, external, relative];
+/** Tries the embedder's resolvers first, then the shipped ones. Unclaimed means unresolved, no probes. */
+export function resolve(request, base, host, resolvers = []) {
+    const resolver = [...resolvers, ...shipped].find(r => r.claims(request));
+    return resolver ? resolver.resolve(request, base, host) : Promise.resolve({ probes: [] });
+}

package/dist/session.d.ts

@@ -0,0 +1,11 @@
+import type { Handler, Host, Resolver, Session, Writer } from "./index.ts";
+export declare function openSession(options: {
+    host: Host;
+    entry: string;
+    handlers: readonly Handler[];
+    resolvers?: readonly Resolver[];
+    /** The editing half of the format plug-ins; the first that claims a location is its writer. */
+    writers?: readonly Writer[];
+    /** Locations under which a commit may write. Absent means nothing is writable. */
+    writable?: readonly string[];
+}): Promise<Session>;