@manta-eu/react 0.1.0

package/dist/hooks/use-entity.js

@@ -0,0 +1,92 @@
+import { isQueryableTermIri } from "@manta-eu/datalog-parser";
+import { isPresent } from "@manta-eu/lib/present";
+import { useQuery } from "@tanstack/react-query";
+import { createLens } from "ldkit";
+import { useSparqlOptions } from "./use-sparql-options.js";
+const batchWindowMs = 0;
+const maxBatchIris = 100;
+const batchesByOptions = new WeakMap();
+async function runQuery(schema, iris, options) {
+    const lens = createLens(schema, options);
+    const found = await lens.findByIris(iris);
+    return new Map(found.map((entity) => [entity.$id, entity]));
+}
+function openBatch(schema, options, bySchema) {
+    const iris = new Set();
+    const result = new Promise((resolve, reject) => {
+        setTimeout(() => {
+            if (bySchema.get(schema) === batch)
+                bySchema.delete(schema);
+            runQuery(schema, [...iris], options).then(resolve, reject);
+        }, batchWindowMs);
+    });
+    const batch = { iris, result };
+    return batch;
+}
+function claimBatches(schema, iris, options) {
+    const bySchema = batchesByOptions.get(options) ?? new Map();
+    batchesByOptions.set(options, bySchema);
+    const claims = [];
+    let remaining = iris;
+    while (remaining.length > 0) {
+        const open = bySchema.get(schema);
+        const batch = open && open.iris.size < maxBatchIris ? open : openBatch(schema, options, bySchema);
+        bySchema.set(schema, batch);
+        const claimed = remaining.slice(0, maxBatchIris - batch.iris.size);
+        for (const iri of claimed)
+            batch.iris.add(iri);
+        claims.push({ batch, iris: claimed });
+        remaining = remaining.slice(claimed.length);
+    }
+    return claims;
+}
+export function loadEntities(schema, iris, options) {
+    const unique = [...new Set(iris)];
+    const parts = claimBatches(schema, unique, options).map((claim) => claim.batch.result.catch(() => runQuery(schema, claim.iris, options)));
+    const merged = parts.length === 1
+        ? parts[0]
+        : Promise.all(parts).then((maps) => new Map(maps.flatMap((map) => [...map])));
+    return merged;
+}
+export const entityQueryKey = (iri, schema) => ["ldo-ui", "entity", iri, schema];
+export const entitiesQueryKey = (schema) => ["ldo-ui", "entities", schema];
+export const entitiesByIrisQueryKey = (iris, schema) => ["ldo-ui", "entities-by-iris", iris, schema];
+const entityStaleTime = 5 * 60 * 1000;
+export function useEntity(config) {
+    const { schema, iri, enabled = true } = config;
+    const options = useSparqlOptions();
+    return useQuery({
+        queryKey: entityQueryKey(iri, schema),
+        queryFn: async () => (await loadEntities(schema, [iri], options)).get(iri) ?? null,
+        staleTime: entityStaleTime,
+        // Blank nodes reach these views as terms SPARQL can't name; `<term>` would be malformed.
+        enabled: enabled && isQueryableTermIri(iri),
+    });
+}
+export function useEntitiesByIris(config) {
+    const { schema, iris, enabled = true } = config;
+    const options = useSparqlOptions();
+    const queryableIris = iris.filter(isQueryableTermIri);
+    return useQuery({
+        queryKey: entitiesByIrisQueryKey(iris, schema),
+        queryFn: async () => {
+            const byIri = await loadEntities(schema, queryableIris, options);
+            return iris.map((iri) => byIri.get(iri));
+        },
+        staleTime: entityStaleTime,
+        enabled: enabled && isPresent(queryableIris),
+    });
+}
+export function useEntities(config) {
+    const { schema, enabled = true } = config;
+    const options = useSparqlOptions();
+    return useQuery({
+        queryKey: entitiesQueryKey(schema),
+        queryFn: async () => {
+            const lens = createLens(schema, options);
+            return lens.find();
+        },
+        staleTime: entityStaleTime,
+        enabled,
+    });
+}

package/dist/hooks/use-install-prompt.d.ts

@@ -0,0 +1,12 @@
+export type InstallOutcome = "accepted" | "dismissed" | "unavailable";
+export type InstallPromptState = {
+    /** Chrome/Android captured a beforeinstallprompt and can show the native prompt. */
+    canPrompt: boolean;
+    /** iOS Safari has no prompt API - the user must add to home screen manually. */
+    isIos: boolean;
+    /** The app is already running installed (standalone display mode). */
+    isInstalled: boolean;
+    promptInstall: () => Promise<InstallOutcome>;
+};
+export declare function useInstallPrompt(): InstallPromptState;
+//# sourceMappingURL=use-install-prompt.d.ts.map

package/dist/hooks/use-install-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-install-prompt.d.ts","sourceRoot":"","sources":["../../src/hooks/use-install-prompt.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,WAAW,GAAG,aAAa,CAAC;AAiBtE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,oFAAoF;IACpF,SAAS,EAAE,OAAO,CAAC;IACnB,gFAAgF;IAChF,KAAK,EAAE,OAAO,CAAC;IACf,sEAAsE;IACtE,WAAW,EAAE,OAAO,CAAC;IACrB,aAAa,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,CAAC;CAC9C,CAAC;AAEF,wBAAgB,gBAAgB,IAAI,kBAAkB,CAgCrD"}

package/dist/hooks/use-install-prompt.js

@@ -0,0 +1,45 @@
+import { useEffect, useState } from "react";
+function runningStandalone() {
+    if (typeof window === "undefined")
+        return false;
+    const displayModeStandalone = window.matchMedia?.("(display-mode: standalone)").matches ?? false;
+    const iosStandalone = window.navigator.standalone === true;
+    return displayModeStandalone || iosStandalone;
+}
+function isIosSafari() {
+    if (typeof window === "undefined")
+        return false;
+    const ua = window.navigator.userAgent;
+    const isIosDevice = /iphone|ipad|ipod/i.test(ua) || (ua.includes("Macintosh") && "ontouchend" in document);
+    const isWebkit = /webkit/i.test(ua) && !/crios|fxios|edgios/i.test(ua);
+    return isIosDevice && isWebkit;
+}
+export function useInstallPrompt() {
+    const [deferredPrompt, setDeferredPrompt] = useState(null);
+    const [isInstalled, setIsInstalled] = useState(runningStandalone);
+    useEffect(() => {
+        const onBeforeInstallPrompt = (event) => {
+            event.preventDefault();
+            setDeferredPrompt(event);
+        };
+        const onInstalled = () => {
+            setIsInstalled(true);
+            setDeferredPrompt(null);
+        };
+        window.addEventListener("beforeinstallprompt", onBeforeInstallPrompt);
+        window.addEventListener("appinstalled", onInstalled);
+        return () => {
+            window.removeEventListener("beforeinstallprompt", onBeforeInstallPrompt);
+            window.removeEventListener("appinstalled", onInstalled);
+        };
+    }, []);
+    async function promptInstall() {
+        if (!deferredPrompt)
+            return "unavailable";
+        await deferredPrompt.prompt();
+        const { outcome } = await deferredPrompt.userChoice;
+        setDeferredPrompt(null);
+        return outcome;
+    }
+    return { canPrompt: deferredPrompt !== null, isIos: isIosSafari(), isInstalled, promptInstall };
+}

package/dist/hooks/use-instance-labels.d.ts

@@ -0,0 +1,7 @@
+import { type ResolvedTerms } from "./resolved-terms.js";
+export type InstanceLabel = string | null;
+export type InstanceLabelsContextValue = ResolvedTerms<InstanceLabel>;
+export declare const InstanceLabelsContext: import("react").Context<ResolvedTerms<InstanceLabel> | null>;
+export declare const useInstanceLabels: (iris: string[]) => Map<string, InstanceLabel>;
+export declare const useInstanceLabel: (iri?: string) => InstanceLabel | undefined;
+//# sourceMappingURL=use-instance-labels.d.ts.map

package/dist/hooks/use-instance-labels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-instance-labels.d.ts","sourceRoot":"","sources":["../../src/hooks/use-instance-labels.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAElF,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,IAAI,CAAC;AAE1C,MAAM,MAAM,0BAA0B,GAAG,aAAa,CAAC,aAAa,CAAC,CAAC;AAItE,eAAO,MAAM,qBAAqB,8DAAmB,CAAC;AACtD,eAAO,MAAM,iBAAiB,gDAA4B,CAAC;AAC3D,eAAO,MAAM,gBAAgB,6CAA2B,CAAC"}

package/dist/hooks/use-instance-labels.js

@@ -0,0 +1,5 @@
+import { createResolvedTermsContext } from "./resolved-terms.js";
+const resolver = createResolvedTermsContext();
+export const InstanceLabelsContext = resolver.Context;
+export const useInstanceLabels = resolver.useResolvedTerms;
+export const useInstanceLabel = resolver.useResolvedTerm;

package/dist/hooks/use-is-mobile.d.ts

@@ -0,0 +1,2 @@
+export declare function useIsMobile(): boolean;
+//# sourceMappingURL=use-is-mobile.d.ts.map

package/dist/hooks/use-is-mobile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-is-mobile.d.ts","sourceRoot":"","sources":["../../src/hooks/use-is-mobile.ts"],"names":[],"mappings":"AAIA,wBAAgB,WAAW,YAE1B"}

package/dist/hooks/use-is-mobile.js

@@ -0,0 +1,5 @@
+import { useMediaQuery } from "usehooks-ts";
+const maxMobileWidth = 768;
+export function useIsMobile() {
+    return useMediaQuery(`(max-width: ${maxMobileWidth - 1}px)`);
+}

package/dist/hooks/use-latest-rendered-template.d.ts

@@ -0,0 +1,15 @@
+export type LatestRenderedTemplate = {
+    text: string;
+    contentType: string | undefined;
+    dateCreated: string | undefined;
+};
+export declare const latestRenderedTemplateQueryKey: (templateIri: string) => readonly ["ldo-ui", "latest-rendered-template", string];
+export declare function useLatestRenderedTemplate(templateIri: string): {
+    data: {
+        text: string;
+        contentType: string | undefined;
+        dateCreated: string | undefined;
+    } | undefined;
+    error: Error | null;
+};
+//# sourceMappingURL=use-latest-rendered-template.d.ts.map

package/dist/hooks/use-latest-rendered-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-latest-rendered-template.d.ts","sourceRoot":"","sources":["../../src/hooks/use-latest-rendered-template.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC,CAAC;AAEF,eAAO,MAAM,8BAA8B,GAAI,aAAa,MAAM,4DACJ,CAAC;AAK/D,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,MAAM;;;;;;;EA8B5D"}

package/dist/hooks/use-latest-rendered-template.js

@@ -0,0 +1,40 @@
+import { expandPrefix, isValidFullIri } from "@manta-eu/rdf-lib/namespaces";
+import { DataFactory } from "ldkit/rdf";
+import { SELECT } from "ldkit/sparql";
+import { useSparqlSelect } from "./use-sparql-construct.js";
+const df = new DataFactory();
+const snapshotOfIri = expandPrefix(":snapshotOf");
+const textIri = expandPrefix("schema:text");
+const contentTypeIri = expandPrefix(":contentType");
+const dateCreatedIri = expandPrefix("schema:dateCreated");
+export const latestRenderedTemplateQueryKey = (templateIri) => ["ldo-ui", "latest-rendered-template", templateIri];
+// Walk from a template instance to its most recent m:RenderedTemplate via m:snapshotOf. The shape
+// declares snapshotOf as sh:maxCount 1 optional but `template.clj/render!!` always writes it, so
+// this is the only link the FE needs. schema:text lives inline on RenderedTemplate — zero S3 fetch.
+export function useLatestRenderedTemplate(templateIri) {
+    const safe = isValidFullIri(templateIri);
+    const template = safe ? df.namedNode(templateIri) : undefined;
+    const query = template
+        ? SELECT `?text ?contentType ?date`.WHERE `
+        ?rt <${snapshotOfIri}> ${template} ;
+            <${textIri}> ?text .
+        OPTIONAL { ?rt <${contentTypeIri}> ?contentType }
+        OPTIONAL { ?rt <${dateCreatedIri}> ?date }
+      `.ORDER_BY `DESC(?date)`
+            .LIMIT(1)
+            .build()
+        : "";
+    const queryResult = useSparqlSelect({
+        query,
+        queryKey: latestRenderedTemplateQueryKey(templateIri),
+        enabled: safe,
+    });
+    const row = queryResult.data?.[0];
+    const text = row?.get("text")?.value;
+    const contentType = row?.get("contentType")?.value;
+    const dateCreated = row?.get("date")?.value;
+    return {
+        data: text ? { text, contentType, dateCreated } : undefined,
+        error: queryResult.error,
+    };
+}

package/dist/hooks/use-manual-actions.d.ts

@@ -0,0 +1,24 @@
+export declare const manualActionStatuses: readonly ["PENDING", "COMPLETED", "REJECTED"];
+export type ManualActionStatus = (typeof manualActionStatuses)[number];
+export type ManualAction = {
+    subjectIri: string;
+    subjectLabel: string | null;
+    typeIri: string;
+    typeName: string;
+    status: ManualActionStatus | null;
+    assignees: string[];
+};
+export type UseManualActionsOptions = {
+    planGraphIri: string;
+    enabled?: boolean;
+    refetchIntervalMs?: number | false;
+};
+export declare function useManualActions(config: UseManualActionsOptions): import("@tanstack/react-query").UseQueryResult<ManualAction[], Error>;
+export declare function useInvalidateManualActions(): (planGraphIri: string) => Promise<void>;
+export type UseManualActionsForPlansOptions = {
+    planGraphIris: string[];
+    enabled?: boolean;
+    refetchIntervalMs?: number | false;
+};
+export declare function useManualActionsForPlans(config: UseManualActionsForPlansOptions): import("@tanstack/react-query").UseQueryResult<Map<string, ManualAction[]>, Error>;
+//# sourceMappingURL=use-manual-actions.d.ts.map

package/dist/hooks/use-manual-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-manual-actions.d.ts","sourceRoot":"","sources":["../../src/hooks/use-manual-actions.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,oBAAoB,+CAAgD,CAAC;AAElF,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AASvE,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,kBAAkB,GAAG,IAAI,CAAC;IAClC,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CACpC,CAAC;AAuDF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,yEAmB/D;AAED,wBAAgB,0BAA0B,KAEhC,cAAc,MAAM,mBAC7B;AAED,MAAM,MAAM,+BAA+B,GAAG;IAC5C,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CACpC,CAAC;AAuCF,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,+BAA+B,sFAqB/E"}

package/dist/hooks/use-manual-actions.js

@@ -0,0 +1,142 @@
+import { m } from "@manta-eu/rdf-lib/namespaces";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { extractTypeName, extractLabel } from "../lib/iri-labels.js";
+import { collectBindings, bindingValue, bindingNodeIri } from "../lib/rdf-helpers.js";
+import { useSparqlEngine, useSparqlOptions } from "./use-sparql-options.js";
+export const manualActionStatuses = ["PENDING", "COMPLETED", "REJECTED"];
+function normalizeManualActionStatus(value) {
+    if (!value)
+        return null;
+    const localName = value.split(/[#/]/).pop() ?? value;
+    const upper = localName.toUpperCase();
+    return manualActionStatuses.includes(upper) ? upper : null;
+}
+function buildManualActionsQuery(planGraphIri) {
+    return `
+    SELECT DISTINCT ?subject ?type ?status ?assignee
+    WHERE {
+      GRAPH <${planGraphIri}> {
+        ?subject <${m.isManualAction}> true .
+        ?subject <${m.status}> ?status .
+        ?subject a ?type .
+        OPTIONAL { ?subject <${m.assignee}> ?assignee }
+      }
+    }
+    ORDER BY ?type ?subject
+  `;
+}
+function parseManualActions(bindings) {
+    const bySubject = new Map();
+    for (const binding of bindings) {
+        const subjectIri = bindingNodeIri(binding, "subject");
+        const typeIri = bindingValue(binding, "type");
+        const status = bindingValue(binding, "status");
+        const assignee = bindingValue(binding, "assignee");
+        if (!subjectIri || !typeIri)
+            continue;
+        let entry = bySubject.get(subjectIri);
+        if (!entry) {
+            entry = { typeIri, status, assignees: new Set() };
+            bySubject.set(subjectIri, entry);
+        }
+        if (status)
+            entry.status = status;
+        if (assignee)
+            entry.assignees.add(assignee);
+    }
+    return Array.from(bySubject.entries()).map(([subjectIri, entry]) => {
+        const subjectLabel = extractLabel(subjectIri);
+        return {
+            subjectIri,
+            subjectLabel: subjectLabel || null,
+            typeIri: entry.typeIri,
+            typeName: extractTypeName(entry.typeIri),
+            status: normalizeManualActionStatus(entry.status),
+            assignees: Array.from(entry.assignees),
+        };
+    });
+}
+function manualActionsQueryKey(planGraphIri) {
+    return ["ldo-ui", planGraphIri, "manual-actions"];
+}
+export function useManualActions(config) {
+    const { planGraphIri, enabled = true, refetchIntervalMs = false } = config;
+    const engine = useSparqlEngine();
+    const options = useSparqlOptions();
+    return useQuery({
+        queryKey: [...manualActionsQueryKey(planGraphIri), engine, options],
+        queryFn: async () => {
+            const query = buildManualActionsQuery(planGraphIri);
+            const stream = await engine.queryBindings(query, options);
+            const bindings = await collectBindings(stream);
+            return parseManualActions(bindings);
+        },
+        enabled: enabled && !!planGraphIri,
+        refetchInterval: refetchIntervalMs,
+        refetchIntervalInBackground: true,
+        refetchOnMount: "always",
+        refetchOnWindowFocus: "always",
+    });
+}
+export function useInvalidateManualActions() {
+    const queryClient = useQueryClient();
+    return (planGraphIri) => queryClient.invalidateQueries({ queryKey: manualActionsQueryKey(planGraphIri) });
+}
+function buildManualActionsForPlansQuery(planGraphIris) {
+    const values = planGraphIris.map((iri) => `<${iri}>`).join(" ");
+    return `
+    SELECT DISTINCT ?graph ?subject ?type ?status ?assignee
+    WHERE {
+      VALUES ?graph { ${values} }
+      GRAPH ?graph {
+        ?subject <${m.isManualAction}> true .
+        ?subject <${m.status}> ?status .
+        ?subject a ?type .
+        OPTIONAL { ?subject <${m.assignee}> ?assignee }
+      }
+    }
+    ORDER BY ?graph ?type ?subject
+  `;
+}
+function parseManualActionsByGraph(bindings) {
+    const byGraph = new Map();
+    for (const binding of bindings) {
+        const graphIri = bindingValue(binding, "graph");
+        if (!graphIri)
+            continue;
+        const existing = byGraph.get(graphIri);
+        if (existing) {
+            existing.push(binding);
+        }
+        else {
+            byGraph.set(graphIri, [binding]);
+        }
+    }
+    const result = new Map();
+    for (const [graphIri, graphBindings] of byGraph) {
+        result.set(graphIri, parseManualActions(graphBindings));
+    }
+    return result;
+}
+export function useManualActionsForPlans(config) {
+    const { planGraphIris, enabled = true, refetchIntervalMs = false } = config;
+    const engine = useSparqlEngine();
+    const options = useSparqlOptions();
+    const sortedIris = [...planGraphIris].sort();
+    return useQuery({
+        queryKey: ["ldo-ui", "manual-actions-for-plans", sortedIris, engine, options],
+        queryFn: async () => {
+            if (sortedIris.length === 0)
+                return new Map();
+            const query = buildManualActionsForPlansQuery(sortedIris);
+            const stream = await engine.queryBindings(query, options);
+            const bindings = await collectBindings(stream);
+            return parseManualActionsByGraph(bindings);
+        },
+        enabled: enabled && sortedIris.length > 0,
+        refetchInterval: refetchIntervalMs,
+        refetchIntervalInBackground: true,
+        refetchOnMount: "always",
+        refetchOnWindowFocus: "always",
+    });
+}

package/dist/hooks/use-ontology-terms.d.ts

@@ -0,0 +1,7 @@
+import type { OntologyTerm } from "../lib/ontology-terms.js";
+import { type ResolvedTerms } from "./resolved-terms.js";
+export type OntologyTermsContextValue = ResolvedTerms<OntologyTerm>;
+export declare const OntologyTermsContext: import("react").Context<ResolvedTerms<OntologyTerm> | null>;
+export declare const useOntologyTerms: (iris: string[]) => Map<string, OntologyTerm>;
+export declare const useOntologyTerm: (iri?: string) => OntologyTerm | undefined;
+//# sourceMappingURL=use-ontology-terms.d.ts.map

package/dist/hooks/use-ontology-terms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-ontology-terms.d.ts","sourceRoot":"","sources":["../../src/hooks/use-ontology-terms.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAA8B,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAElF,MAAM,MAAM,yBAAyB,GAAG,aAAa,CAAC,YAAY,CAAC,CAAC;AAIpE,eAAO,MAAM,oBAAoB,6DAAmB,CAAC;AACrD,eAAO,MAAM,gBAAgB,+CAA4B,CAAC;AAC1D,eAAO,MAAM,eAAe,4CAA2B,CAAC"}

package/dist/hooks/use-ontology-terms.js

@@ -0,0 +1,5 @@
+import { createResolvedTermsContext } from "./resolved-terms.js";
+const resolver = createResolvedTermsContext();
+export const OntologyTermsContext = resolver.Context;
+export const useOntologyTerms = resolver.useResolvedTerms;
+export const useOntologyTerm = resolver.useResolvedTerm;

package/dist/hooks/use-redirect-endpoint.d.ts

@@ -0,0 +1,4 @@
+export declare const defaultRedirectEndpoint = "/redirect";
+export declare const RedirectEndpointContext: import("react").Context<string>;
+export declare function useRedirectEndpoint(): string;
+//# sourceMappingURL=use-redirect-endpoint.d.ts.map

package/dist/hooks/use-redirect-endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-redirect-endpoint.d.ts","sourceRoot":"","sources":["../../src/hooks/use-redirect-endpoint.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,uBAAuB,cAAc,CAAC;AAEnD,eAAO,MAAM,uBAAuB,iCAAiD,CAAC;AAEtF,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C"}

package/dist/hooks/use-redirect-endpoint.js

@@ -0,0 +1,6 @@
+import { createContext, useContext } from "react";
+export const defaultRedirectEndpoint = "/redirect";
+export const RedirectEndpointContext = createContext(defaultRedirectEndpoint);
+export function useRedirectEndpoint() {
+    return useContext(RedirectEndpointContext);
+}

package/dist/hooks/use-should-auto-focus-input.d.ts

@@ -0,0 +1,2 @@
+export declare function useShouldAutoFocusInput(): boolean;
+//# sourceMappingURL=use-should-auto-focus-input.d.ts.map

package/dist/hooks/use-should-auto-focus-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-should-auto-focus-input.d.ts","sourceRoot":"","sources":["../../src/hooks/use-should-auto-focus-input.ts"],"names":[],"mappings":"AAIA,wBAAgB,uBAAuB,YAEtC"}

package/dist/hooks/use-should-auto-focus-input.js

@@ -0,0 +1,5 @@
+import { useMediaQuery } from "usehooks-ts";
+const supportsPreciseHoverQuery = "(hover: hover) and (pointer: fine)";
+export function useShouldAutoFocusInput() {
+    return useMediaQuery(supportsPreciseHoverQuery);
+}

package/dist/hooks/use-sparql-construct.d.ts

@@ -0,0 +1,18 @@
+import type { RDF } from "ldkit/rdf";
+import { type RdfGraph } from "../lib/rdf-helpers.js";
+export type UseSparqlConstructOptions = {
+    query: string;
+    queryKey: readonly unknown[];
+    enabled?: boolean;
+    keepPreviousData?: boolean;
+    staleTime?: number;
+};
+export declare function useSparqlConstruct(config: UseSparqlConstructOptions): import("@tanstack/react-query").UseQueryResult<RdfGraph, Error>;
+export type UseSparqlSelectOptions = {
+    query: string;
+    queryKey: readonly unknown[];
+    enabled?: boolean;
+    staleTime?: number;
+};
+export declare function useSparqlSelect(config: UseSparqlSelectOptions): import("@tanstack/react-query").UseQueryResult<RDF.Bindings[], Error>;
+//# sourceMappingURL=use-sparql-construct.d.ts.map

package/dist/hooks/use-sparql-construct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-sparql-construct.d.ts","sourceRoot":"","sources":["../../src/hooks/use-sparql-construct.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAErC,OAAO,EAAwC,KAAK,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAOzF,MAAM,MAAM,yBAAyB,GAAG;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,yBAAyB,mEAenE;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,wBAAgB,eAAe,CAAC,MAAM,EAAE,sBAAsB,yEAc7D"}

package/dist/hooks/use-sparql-construct.js

@@ -0,0 +1,36 @@
+import { keepPreviousData, useQuery } from "@tanstack/react-query";
+import { withAbortSignal } from "../engine.js";
+import { collectBindings, collectQuadsToGraph } from "../lib/rdf-helpers.js";
+import { useSparqlEngine, useSparqlOptions } from "./use-sparql-options.js";
+function optionsToContext(options) {
+    return options;
+}
+export function useSparqlConstruct(config) {
+    const { query, queryKey, enabled = true, staleTime } = config;
+    const engine = useSparqlEngine();
+    const options = useSparqlOptions();
+    return useQuery({
+        queryKey,
+        queryFn: async ({ signal }) => {
+            const stream = await engine.queryQuads(query, optionsToContext(withAbortSignal(options, signal)));
+            return collectQuadsToGraph(stream);
+        },
+        enabled: enabled && !!query,
+        staleTime,
+        placeholderData: config.keepPreviousData ? keepPreviousData : undefined,
+    });
+}
+export function useSparqlSelect(config) {
+    const { query, queryKey, enabled = true, staleTime } = config;
+    const engine = useSparqlEngine();
+    const options = useSparqlOptions();
+    return useQuery({
+        queryKey,
+        queryFn: async ({ signal }) => {
+            const stream = await engine.queryBindings(query, optionsToContext(withAbortSignal(options, signal)));
+            return collectBindings(stream);
+        },
+        enabled: enabled && !!query,
+        staleTime,
+    });
+}

package/dist/hooks/use-sparql-options.d.ts

@@ -0,0 +1,13 @@
+import type { Options, QueryEngine, QueryContext } from "ldkit";
+export type SparqlContextValue = {
+    options: Options;
+    writeOptions?: Options;
+    engine: QueryEngine;
+};
+export declare const SparqlContext: import("react").Context<SparqlContextValue | null>;
+export declare function useSparqlOptions(): Options;
+export declare function useSparqlEngine(): QueryEngine;
+/** Throws unless the provider was given `writeOptions` — the read `options` write to the wrong endpoint. */
+export declare function useSparqlWriteOptions(): Options;
+export declare function optionsToContext(options: Options): QueryContext;
+//# sourceMappingURL=use-sparql-options.d.ts.map

package/dist/hooks/use-sparql-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-sparql-options.d.ts","sourceRoot":"","sources":["../../src/hooks/use-sparql-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAGhE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,EAAE,WAAW,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,aAAa,oDAAiD,CAAC;AAU5E,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C;AAED,wBAAgB,eAAe,IAAI,WAAW,CAE7C;AAED,4GAA4G;AAC5G,wBAAgB,qBAAqB,IAAI,OAAO,CAM/C;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,YAAY,CAE/D"}

package/dist/hooks/use-sparql-options.js

@@ -0,0 +1,26 @@
+import { createContext, useContext } from "react";
+export const SparqlContext = createContext(null);
+function useSparqlContext() {
+    const ctx = useContext(SparqlContext);
+    if (!ctx) {
+        throw new Error("useSparqlOptions/useSparqlEngine must be used within a SparqlOptionsProvider");
+    }
+    return ctx;
+}
+export function useSparqlOptions() {
+    return useSparqlContext().options;
+}
+export function useSparqlEngine() {
+    return useSparqlContext().engine;
+}
+/** Throws unless the provider was given `writeOptions` — the read `options` write to the wrong endpoint. */
+export function useSparqlWriteOptions() {
+    const { writeOptions } = useSparqlContext();
+    if (!writeOptions) {
+        throw new Error("useSparqlWriteOptions requires writeOptions on the SparqlOptionsProvider");
+    }
+    return writeOptions;
+}
+export function optionsToContext(options) {
+    return options;
+}

package/dist/hooks/use-sparql-query.d.ts

@@ -0,0 +1,16 @@
+import { type UseQueryResult } from "@tanstack/react-query";
+import { type Options, type Schema } from "ldkit";
+import type { LensEntity } from "./lens-entity.js";
+export type UseSparqlQueryOptions<S extends Schema> = {
+    schema: S;
+    options: Options;
+    iri?: string;
+    enabled?: boolean;
+    queryKey: readonly unknown[];
+};
+export declare function useLensFind<S extends Schema>(config: UseSparqlQueryOptions<S>): UseQueryResult<LensEntity<S>[], Error>;
+export declare function useLensFindByIri<S extends Schema>(config: UseSparqlQueryOptions<S> & {
+    iri: string;
+}): UseQueryResult<LensEntity<S> | null, Error>;
+export declare function useLensCount<S extends Schema>(config: Omit<UseSparqlQueryOptions<S>, "iri">): UseQueryResult<number, Error>;
+//# sourceMappingURL=use-sparql-query.d.ts.map

package/dist/hooks/use-sparql-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-sparql-query.d.ts","sourceRoot":"","sources":["../../src/hooks/use-sparql-query.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,KAAK,OAAO,EAAc,KAAK,MAAM,EAAE,MAAM,OAAO,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,MAAM,MAAM,qBAAqB,CAAC,CAAC,SAAS,MAAM,IAAI;IACpD,MAAM,EAAE,CAAC,CAAC;IACV,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;CAC9B,CAAC;AAEF,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAC1C,MAAM,EAAE,qBAAqB,CAAC,CAAC,CAAC,GAC/B,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,CAAC,CAWxC;AAED,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAC/C,MAAM,EAAE,qBAAqB,CAAC,CAAC,CAAC,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GACjD,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,CAW7C;AAED,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,iCAW3F"}

package/dist/hooks/use-sparql-query.js

@@ -0,0 +1,35 @@
+import { useQuery } from "@tanstack/react-query";
+import { createLens } from "ldkit";
+export function useLensFind(config) {
+    const { schema, options, enabled = true, queryKey } = config;
+    return useQuery({
+        queryKey,
+        queryFn: async () => {
+            const lens = createLens(schema, options);
+            return lens.find();
+        },
+        enabled,
+    });
+}
+export function useLensFindByIri(config) {
+    const { schema, options, iri, enabled = true, queryKey } = config;
+    return useQuery({
+        queryKey,
+        queryFn: async () => {
+            const lens = createLens(schema, options);
+            return lens.findByIri(iri);
+        },
+        enabled: enabled && !!iri,
+    });
+}
+export function useLensCount(config) {
+    const { schema, options, enabled = true, queryKey } = config;
+    return useQuery({
+        queryKey,
+        queryFn: async () => {
+            const lens = createLens(schema, options);
+            return lens.count();
+        },
+        enabled,
+    });
+}