@manta-eu/react 0.1.0 → 0.1.2

package/dist/routes/rules/components/datalog-editor/FactsPreview.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { namespaces } from "@manta-eu/client/shared/rdf-namespaces";
+import { isPresent } from "@manta-eu/lib/present";
+import { AlertCircle, ChevronDown, ChevronRight, Database, TrendingUp } from "lucide-react";
+import { forwardRef, useState } from "react";
+import { useDebounceValue } from "usehooks-ts";
+import { useRuleFactsPreview } from "../../hooks/useRuleFactsPreview.js";
+import { Badge } from "#components/badge/index";
+import { Button } from "#components/button/index";
+import { Skeleton } from "#components/skeleton/index";
+import { cn } from "#lib/utils";
+import { useMantaClient } from "#providers/MantaClientProvider";
+const compactNumber = new Intl.NumberFormat("en", { notation: "compact", maximumFractionDigits: 1 });
+function formatCount(count) {
+    return compactNumber.format(count);
+}
+function getCountColor(count) {
+    if (count === 0)
+        return "text-muted-foreground";
+    if (count < 100)
+        return "text-success";
+    if (count < 1000)
+        return "text-warning";
+    return "text-error-foreground";
+}
+export const FactsPreview = forwardRef(function FactsPreview(props, ref) {
+    const { mantaClient } = useMantaClient();
+    const { rule, ast, prefixes = namespaces, sampleLimit = 10, className, ...restProps } = props;
+    const [showSamples, setShowSamples] = useState(true);
+    const [debouncedRule] = useDebounceValue(rule, 500);
+    const [debouncedAst] = useDebounceValue(ast, 500);
+    const hasQueryableRule = !!debouncedAst && isPresent(debouncedAst.head) && isPresent(debouncedAst.body);
+    const factsPreview = useRuleFactsPreview({
+        rule: debouncedRule,
+        graphqlClient: mantaClient,
+        prefixes,
+        enabled: hasQueryableRule,
+        sampleLimit,
+    });
+    return (_jsxs("div", { ref: ref, className: cn("border rounded-lg overflow-hidden", className), ...restProps, children: [_jsx("div", { className: "bg-muted/30 px-4 py-2 border-b", children: _jsxs("div", { className: "flex items-center justify-between", children: [_jsxs("div", { className: "flex items-center gap-2", children: [_jsx(Database, { className: "size-4 text-muted-foreground" }), _jsx("h4", { className: "typography-caption text-muted-foreground", children: "Facts Preview" })] }), factsPreview.factCount !== null && (_jsxs("div", { className: "flex items-center gap-2", children: [_jsx(TrendingUp, { className: "size-4 text-muted-foreground" }), _jsxs("span", { className: cn("typography-caption", getCountColor(factsPreview.factCount)), children: [formatCount(factsPreview.factCount), " facts"] })] }))] }) }), _jsx("div", { className: "p-4", children: !debouncedAst ? (_jsx("p", { className: "typography-small text-muted-foreground", children: "Enter a valid rule to see inferred facts" })) : !isPresent(debouncedAst.head) ? (_jsx("p", { className: "typography-small text-muted-foreground", children: "Add head atoms to see inferred facts preview" })) : !isPresent(debouncedAst.body) ? (_jsx("p", { className: "typography-small text-muted-foreground", children: "Add body formulas to infer facts" })) : factsPreview.isLoadingCount ? (_jsx("div", { className: "space-y-3", children: _jsxs("div", { className: "flex items-center gap-2", children: [_jsx(Skeleton, { className: "h-6 w-24" }), _jsx(Skeleton, { className: "h-6 w-16" })] }) })) : factsPreview.error ? (_jsxs("div", { className: "flex items-start gap-2 text-error-foreground", children: [_jsx(AlertCircle, { className: "size-4 mt-0.5 shrink-0" }), _jsx("p", { className: "typography-small", children: factsPreview.error })] })) : (_jsxs("div", { className: "space-y-4", children: [factsPreview.factCount !== null && (_jsxs("div", { className: "flex items-center justify-between p-3 bg-muted/20 rounded-lg border border-muted", children: [_jsxs("div", { children: [_jsx("p", { className: "typography-small", children: "Total Inferred Facts" }), _jsx("p", { className: "typography-caption text-muted-foreground", children: factsPreview.factCount === 0
+                                                ? "No facts would be inferred"
+                                                : `This rule would create ${formatCount(factsPreview.factCount)} new facts` })] }), _jsx(Badge, { size: "sm", variant: factsPreview.factCount === 0 ? "secondary" : "default", children: formatCount(factsPreview.factCount) })] })), factsPreview.factCount !== null && factsPreview.factCount > 0 && (_jsxs("div", { className: "space-y-2", children: [_jsxs(Button, { type: "button", variant: "ghost", size: "sm", onClick: () => setShowSamples(!showSamples), icon: showSamples ? ChevronDown : ChevronRight, className: "w-full justify-start", children: ["Sample Inferred Triples", factsPreview.samples && (_jsxs("span", { className: "ml-auto typography-small text-muted-foreground", children: ["(", Math.min(factsPreview.samples.length, sampleLimit), " shown)"] }))] }), showSamples && (_jsx("div", { className: "space-y-2", children: factsPreview.isLoadingSamples ? (_jsxs(_Fragment, { children: [_jsx(Skeleton, { className: "h-12 w-full" }), _jsx(Skeleton, { className: "h-12 w-5/6" }), _jsx(Skeleton, { className: "h-12 w-4/5" })] })) : isPresent(factsPreview.samples) ? (_jsx("div", { className: "space-y-1.5", children: factsPreview.samples.slice(0, sampleLimit).map((triple) => (_jsx("div", { className: "p-2 bg-background border rounded-md hover:bg-muted/20 transition-colors", children: _jsxs("div", { className: "flex items-start gap-2 font-mono typography-small", children: [_jsx("span", { className: "text-primary break-all", children: triple.subject }), _jsx("span", { className: "text-muted-foreground shrink-0", children: "\u2192" }), _jsx("span", { className: "text-success break-all", children: triple.predicate }), _jsx("span", { className: "text-muted-foreground shrink-0", children: "\u2192" }), _jsx("span", { className: "text-primary break-all", children: triple.object })] }) }, `${triple.subject || "unknown"}-${triple.predicate || "unknown"}-${triple.object || "unknown"}`))) })) : (_jsx("p", { className: "typography-small text-muted-foreground p-2", children: "No sample triples available" })) }))] }))] })) })] }));
+});

package/dist/routes/rules/components/datalog-editor/PreviewPanel.d.ts

@@ -0,0 +1,7 @@
+import type { DatalogRule } from "@manta-eu/datalog-parser";
+export type PreviewPanelProps = {
+    rule: string;
+    ast: DatalogRule | null;
+};
+export declare function PreviewPanel(props: PreviewPanelProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=PreviewPanel.d.ts.map

package/dist/routes/rules/components/datalog-editor/PreviewPanel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreviewPanel.d.ts","sourceRoot":"","sources":["../../../../../src/routes/rules/components/datalog-editor/PreviewPanel.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG5D,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,WAAW,GAAG,IAAI,CAAC;CACzB,CAAC;AAEF,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,2CAqBpD"}

package/dist/routes/rules/components/datalog-editor/PreviewPanel.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { DatalogAst } from "#ldo-ui";
+export function PreviewPanel(props) {
+    const { rule, ast } = props;
+    return (_jsxs("div", { className: "rounded-md border overflow-hidden", children: [_jsx("div", { className: "border-b bg-muted/30 px-4 py-2", children: _jsx("h4", { className: "typography-caption text-muted-foreground", children: "Parsed AST" }) }), _jsx("div", { className: "p-4 overflow-auto max-h-150", children: ast ? (_jsx(DatalogAst, { rule: rule })) : (_jsx("p", { className: "typography-small text-muted-foreground", children: rule.trim()
+                        ? "Fix syntax errors to see the AST visualization"
+                        : "Enter a Datalog rule to see its AST visualization" })) })] }));
+}

package/dist/routes/rules/components/datalog-editor/QueryResults.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentProps } from "react";
+export type QueryResultsProps = ComponentProps<"div"> & {
+    variables: string[];
+    bindings: Record<string, string>[];
+    isLoading?: boolean;
+    error?: string | null;
+};
+export declare const QueryResults: import("react").ForwardRefExoticComponent<Omit<QueryResultsProps, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+//# sourceMappingURL=QueryResults.d.ts.map

package/dist/routes/rules/components/datalog-editor/QueryResults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryResults.d.ts","sourceRoot":"","sources":["../../../../../src/routes/rules/components/datalog-editor/QueryResults.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAK5C,MAAM,MAAM,iBAAiB,GAAG,cAAc,CAAC,KAAK,CAAC,GAAG;IACtD,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IACnC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,YAAY,2HAwGvB,CAAC"}

package/dist/routes/rules/components/datalog-editor/QueryResults.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isPresent } from "@manta-eu/lib/present";
+import { AlertCircle, Database, FileText } from "lucide-react";
+import { forwardRef } from "react";
+import { Loader } from "#components/loader/index";
+import { cn } from "#lib/utils";
+export const QueryResults = forwardRef(function QueryResults(props, ref) {
+    const { variables, bindings, isLoading, error, className, ...restProps } = props;
+    if (isLoading) {
+        return (_jsxs("div", { ref: ref, className: cn("flex items-center justify-center p-8 text-muted-foreground", className), ...restProps, children: [_jsx(Loader, { className: "size-4 mr-2" }), _jsx("span", { className: "typography-small", children: "Running query..." })] }));
+    }
+    if (error) {
+        return (_jsx("div", { ref: ref, className: cn("p-4", className), ...restProps, children: _jsxs("div", { className: "flex items-start gap-2 text-error-foreground", children: [_jsx(AlertCircle, { className: "size-4 mt-0.5 flex-shrink-0" }), _jsxs("div", { className: "typography-small", children: [_jsx("p", { className: "typography-small-medium mb-1", children: "Query Error" }), _jsx("p", { className: "text-error-foreground/80 whitespace-pre-wrap", children: error })] })] }) }));
+    }
+    if (!isPresent(variables) && !isPresent(bindings)) {
+        return (_jsxs("div", { ref: ref, className: cn("flex flex-col items-center justify-center p-8 text-muted-foreground", className), ...restProps, children: [_jsx(Database, { className: "size-8 mb-3 text-muted-foreground/50" }), _jsx("p", { className: "typography-small-medium", children: "No results yet" }), _jsx("p", { className: "typography-caption text-muted-foreground/70 mt-1", children: "Run a query to see results" })] }));
+    }
+    if (!isPresent(bindings)) {
+        return (_jsxs("div", { ref: ref, className: cn("flex flex-col items-center justify-center p-8 text-muted-foreground", className), ...restProps, children: [_jsx(FileText, { className: "size-8 mb-3 text-muted-foreground/50" }), _jsx("p", { className: "typography-small-medium", children: "No matching results" }), _jsx("p", { className: "typography-tiny text-muted-foreground/70 mt-1", children: "The query returned 0 rows" })] }));
+    }
+    return (_jsx("div", { ref: ref, className: cn("overflow-auto", className), ...restProps, children: _jsxs("div", { className: "min-w-full", children: [_jsx("div", { className: "border-b bg-muted/30 px-4 py-2", children: _jsxs("p", { className: "typography-tiny text-muted-foreground", children: [bindings.length, " ", bindings.length === 1 ? "result" : "results"] }) }), _jsxs("table", { className: "w-full", children: [_jsx("thead", { children: _jsx("tr", { className: "border-b bg-muted/50", children: variables.map((variable) => (_jsxs("th", { className: "px-4 py-2 text-left typography-tiny-semibold text-muted-foreground uppercase", children: ["?", variable] }, variable))) }) }), _jsx("tbody", { children: bindings.map((binding, index) => (_jsx("tr", { className: cn("border-b transition-colors", "hover:bg-accent/50", index % 2 === 0 ? "bg-background" : "bg-muted/20"), children: variables.map((variable) => (_jsx("td", { className: "px-4 py-2 typography-small", children: _jsx("span", { className: "font-mono typography-tiny break-all", children: binding[variable] || _jsx("span", { className: "text-muted-foreground/50 italic", children: "null" }) }) }, variable))) }, index))) })] })] }) }));
+});

package/dist/routes/rules/components/datalog-editor/SparqlQueryPanel.d.ts

@@ -0,0 +1,11 @@
+import type { SparqlQueryResult } from "../../hooks/useSparqlQueryExecution.js";
+export type SparqlQueryPanelProps = {
+    query: string | null;
+    isLoading?: boolean;
+    error?: string | null;
+    results?: SparqlQueryResult | null;
+    onExecute?: () => void;
+    onReset?: () => void;
+};
+export declare function SparqlQueryPanel(props: SparqlQueryPanelProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SparqlQueryPanel.d.ts.map

package/dist/routes/rules/components/datalog-editor/SparqlQueryPanel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SparqlQueryPanel.d.ts","sourceRoot":"","sources":["../../../../../src/routes/rules/components/datalog-editor/SparqlQueryPanel.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAI7E,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,OAAO,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAC;IACnC,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;CACtB,CAAC;AAMF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,2CAiE5D"}

package/dist/routes/rules/components/datalog-editor/SparqlQueryPanel.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Copy, Play, RotateCw } from "lucide-react";
+import { useMemo, useState } from "react";
+import { QueryResults } from "./QueryResults.js";
+import { Button } from "#components/button/index";
+function stripPrefixBlock(query) {
+    return query.replace(/^(?:PREFIX[^\n]*\n)+\s*/, "");
+}
+export function SparqlQueryPanel(props) {
+    const { query, isLoading, error, results, onExecute, onReset } = props;
+    const [copied, setCopied] = useState(false);
+    const displayQuery = useMemo(() => (query ? stripPrefixBlock(query) : null), [query]);
+    function handleCopy() {
+        if (displayQuery) {
+            void navigator.clipboard.writeText(displayQuery);
+            setCopied(true);
+            setTimeout(() => setCopied(false), 2000);
+        }
+    }
+    return (_jsxs("div", { className: "flex h-full flex-col rounded-md border overflow-hidden", children: [_jsx("div", { className: "border-b bg-muted/30 px-4 py-2", children: _jsxs("div", { className: "flex items-center justify-between", children: [_jsx("h4", { className: "typography-caption text-muted-foreground", children: "Generated SPARQL Query" }), _jsxs("div", { className: "flex items-center gap-2", children: [_jsx(Button, { type: "button", size: "sm", variant: "ghost", onClick: handleCopy, disabled: !query, icon: Copy, children: copied ? "Copied!" : "Copy" }), results && (_jsx(Button, { type: "button", size: "sm", variant: "ghost", onClick: onReset, disabled: isLoading, icon: RotateCw, children: "Reset" })), _jsx(Button, { type: "button", size: "sm", variant: "primary", onClick: onExecute, disabled: isLoading || !query, icon: Play, children: isLoading ? "Running..." : "Run" })] })] }) }), displayQuery ? (_jsxs(_Fragment, { children: [_jsx("div", { className: "p-4 bg-muted/20 border-b", children: _jsx("pre", { className: "typography-caption font-mono whitespace-pre-wrap break-all text-default-foreground/90", children: displayQuery }) }), _jsx("div", { className: "flex-1 overflow-auto", children: _jsx(QueryResults, { variables: results?.variables || [], bindings: results?.bindings || [], isLoading: isLoading, error: error }) })] })) : (_jsx("p", { className: "p-4 typography-small text-muted-foreground", children: "Enter a valid Datalog rule with body formulas to generate a SPARQL query" }))] }));
+}

package/dist/routes/rules/components/rule-producers.d.ts

@@ -0,0 +1,15 @@
+import type { GQLRule } from "@manta-eu/client";
+import { type DatalogTerm } from "@manta-eu/datalog-parser";
+export type RuleProducer = {
+    ruleIri: string;
+    isStaged: boolean;
+};
+export type ProducerRule = Pick<GQLRule, "ruleIri" | "committedRule" | "stagedRule" | "isStaged">;
+type ProducerEntry = RuleProducer & {
+    graphKeys: Set<string>;
+};
+export type RuleProducerIndex = Map<string, ProducerEntry[]>;
+export declare function buildRuleProducerIndex(rules: readonly ProducerRule[], excludeRuleIri?: string): RuleProducerIndex;
+export declare function lookupRuleProducers(index: RuleProducerIndex, term: string, graph: DatalogTerm | undefined): RuleProducer[];
+export {};
+//# sourceMappingURL=rule-producers.d.ts.map

package/dist/routes/rules/components/rule-producers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-producers.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/rule-producers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAIL,KAAK,WAAW,EACjB,MAAM,0BAA0B,CAAC;AAMlC,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,EAAE,SAAS,GAAG,eAAe,GAAG,YAAY,GAAG,UAAU,CAAC,CAAC;AAElG,KAAK,aAAa,GAAG,YAAY,GAAG;IAAE,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CAAE,CAAC;AAE/D,MAAM,MAAM,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC,CAAC;AAwC7D,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,EAAE,cAAc,CAAC,EAAE,MAAM,GAAG,iBAAiB,CASjH;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,iBAAiB,EACxB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,WAAW,GAAG,SAAS,GAC7B,YAAY,EAAE,CAehB"}

package/dist/routes/rules/components/rule-producers.js

@@ -0,0 +1,76 @@
+import { classAssertionFromAtom, propertyAssertionFromAtom, } from "@manta-eu/datalog-parser";
+import { collectBy, groupBy } from "ramda";
+import { match } from "ts-pattern";
+import { getRuleDisplayName, getRuleDisplayText } from "./rules.utils.js";
+import { ontologyTermIri, parseDatalogRuleCached } from "#ldo-ui";
+const defaultGraphKey = "";
+const anyGraphKey = "*";
+function ruleProducerAssertions(rule) {
+    const ruleText = getRuleDisplayText(rule);
+    if (!ruleText.trim())
+        return [];
+    const { ast } = parseDatalogRuleCached(ruleText);
+    if (!ast)
+        return [];
+    return ast.head.flatMap((atom) => {
+        const assertion = headAssertion(atom);
+        if (!assertion)
+            return [];
+        const termIri = ontologyTermIri(assertion.term);
+        if (!termIri)
+            return [];
+        return [{ ruleIri: rule.ruleIri, isStaged: rule.isStaged, termIri, graphKey: graphTermKey(assertion.graph) }];
+    });
+}
+function toProducerEntries(assertions) {
+    return collectBy((assertion) => assertion.ruleIri, assertions).flatMap((perRule) => {
+        const first = perRule[0];
+        if (!first)
+            return [];
+        return [
+            {
+                ruleIri: first.ruleIri,
+                isStaged: first.isStaged,
+                graphKeys: new Set(perRule.map((assertion) => assertion.graphKey)),
+            },
+        ];
+    });
+}
+export function buildRuleProducerIndex(rules, excludeRuleIri) {
+    const assertions = rules.filter((rule) => rule.ruleIri !== excludeRuleIri).flatMap(ruleProducerAssertions);
+    return new Map(Object.entries(groupBy((assertion) => assertion.termIri, assertions)).map(([termIri, group]) => [
+        termIri,
+        toProducerEntries(group ?? []),
+    ]));
+}
+export function lookupRuleProducers(index, term, graph) {
+    const termIri = ontologyTermIri(term);
+    if (!termIri)
+        return [];
+    const entries = index.get(termIri);
+    if (!entries)
+        return [];
+    const consumerGraphKey = graphTermKey(graph);
+    return entries
+        .filter((entry) => consumerGraphKey === anyGraphKey || entry.graphKeys.has(consumerGraphKey) || entry.graphKeys.has(anyGraphKey))
+        .map(({ ruleIri, isStaged }) => ({ ruleIri, isStaged }))
+        .sort((left, right) => getRuleDisplayName(left.ruleIri).localeCompare(getRuleDisplayName(right.ruleIri)));
+}
+function headAssertion(atom) {
+    const classAssertion = classAssertionFromAtom(atom);
+    if (classAssertion)
+        return { term: classAssertion.className, graph: classAssertion.graph };
+    const propertyAssertion = propertyAssertionFromAtom(atom);
+    if (propertyAssertion)
+        return { term: propertyAssertion.predicate, graph: propertyAssertion.graph };
+    return null;
+}
+function graphTermKey(graph) {
+    return match(graph)
+        .with({ type: "variable" }, () => anyGraphKey)
+        .with({ type: "iri" }, (g) => ontologyTermIri(g.value) ?? g.value)
+        .with({ type: "literal" }, () => defaultGraphKey)
+        .with({ type: "blank" }, () => defaultGraphKey)
+        .with(undefined, () => defaultGraphKey)
+        .exhaustive();
+}

package/dist/routes/rules/components/sample-facts-query.d.ts

@@ -0,0 +1,9 @@
+export declare function buildSampleFactsQuery(ruleText: string, limit?: number): string;
+type HeadConstraintGroup = {
+    graph?: string;
+    predicates: string[];
+    classes: string[];
+};
+export declare function extractHeadConstraints(ruleText: string): HeadConstraintGroup[];
+export {};
+//# sourceMappingURL=sample-facts-query.d.ts.map

package/dist/routes/rules/components/sample-facts-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sample-facts-query.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/sample-facts-query.ts"],"names":[],"mappings":"AAKA,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,MAAM,CA2BzE;AAUD,KAAK,mBAAmB,GAAG;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAEF,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,mBAAmB,EAAE,CA6C9E"}

package/dist/routes/rules/components/sample-facts-query.js

@@ -0,0 +1,71 @@
+import { isIriTerm, termToSparql } from "@manta-eu/datalog-parser";
+import { isPresent } from "@manta-eu/lib/present";
+import { match } from "ts-pattern";
+import { parseDatalogRuleCached } from "#ldo-ui";
+export function buildSampleFactsQuery(ruleText, limit = 5) {
+    const groups = extractHeadConstraints(ruleText);
+    const blocks = groups.flatMap(({ graph, predicates, classes }) => {
+        const groupBlocks = [];
+        if (isPresent(predicates)) {
+            groupBlocks.push(factBlock([`VALUES ?P { ${predicates.join(" ")} }`], graph));
+        }
+        if (isPresent(classes)) {
+            groupBlocks.push(factBlock([`VALUES ?P { rdf:type }`, `VALUES ?O { ${classes.join(" ")} }`], graph));
+        }
+        return groupBlocks;
+    });
+    if (!isPresent(blocks)) {
+        throw new Error("Rule has no concrete head predicates or classes to sample");
+    }
+    const where = blocks.length === 1 ? blocks[0] : blocks.map((block) => `{ ${block} }`).join("\n  UNION\n  ");
+    const projection = groups.some(({ graph }) => isPresent(graph)) ? "?S ?P ?O ?G" : "?S ?P ?O";
+    return `SELECT ${projection} WHERE {
+  ${where}
+} LIMIT ${limit}`;
+}
+function factBlock(constraints, graph) {
+    const patterns = ["?S ?P ?O EXPLICIT FALSE .", ...constraints];
+    if (!graph)
+        return patterns.join("\n  ");
+    return `GRAPH ${graph} { ${[...patterns, `BIND(${graph} AS ?G)`].join("\n  ")} }`;
+}
+export function extractHeadConstraints(ruleText) {
+    const { ast, error } = parseDatalogRuleCached(ruleText);
+    if (error || !ast) {
+        throw new Error(error ?? "Failed to parse rule");
+    }
+    const groups = new Map();
+    const groupFor = (graphTerm) => {
+        const graph = graphTerm && isIriTerm(graphTerm) ? termToSparql(graphTerm) : undefined;
+        const existing = groups.get(graph ?? "");
+        if (existing)
+            return existing;
+        const created = { graph, predicates: new Set(), classes: new Set() };
+        groups.set(graph ?? "", created);
+        return created;
+    };
+    for (const atom of ast.head) {
+        match(atom)
+            .with({ type: "property" }, (propertyAtom) => groupFor(propertyAtom.graph).predicates.add(propertyAtom.predicate))
+            .with({ type: "general" }, (generalAtom) => groupFor().predicates.add(generalAtom.tableName))
+            .with({ type: "class" }, (classAtom) => groupFor(classAtom.graph).classes.add(classAtom.className))
+            .with({ type: "triple" }, (tripleAtom) => {
+            if (!isIriTerm(tripleAtom.predicate))
+                return;
+            const group = groupFor(tripleAtom.graph);
+            const predicate = termToSparql(tripleAtom.predicate);
+            if (predicate === "rdf:type" && isIriTerm(tripleAtom.object)) {
+                group.classes.add(termToSparql(tripleAtom.object));
+            }
+            else {
+                group.predicates.add(predicate);
+            }
+        })
+            .exhaustive();
+    }
+    return [...groups.values()].map(({ graph, predicates, classes }) => ({
+        graph,
+        predicates: [...predicates],
+        classes: [...classes],
+    }));
+}

package/dist/routes/rules/datalog-editor.d.ts

@@ -0,0 +1,6 @@
+export { BindingsPreview, type BindingsPreviewProps } from "./components/datalog-editor/BindingsPreview.js";
+export { FactsPreview, type FactsPreviewProps } from "./components/datalog-editor/FactsPreview.js";
+export { PreviewPanel, type PreviewPanelProps } from "./components/datalog-editor/PreviewPanel.js";
+export { SparqlQueryPanel, type SparqlQueryPanelProps } from "./components/datalog-editor/SparqlQueryPanel.js";
+export { useSparqlQueryExecution, type SparqlQueryResult } from "./hooks/useSparqlQueryExecution.js";
+//# sourceMappingURL=datalog-editor.d.ts.map

package/dist/routes/rules/datalog-editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"datalog-editor.d.ts","sourceRoot":"","sources":["../../../src/routes/rules/datalog-editor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,6CAA6C,CAAC;AACzG,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,0CAA0C,CAAC;AAChG,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,MAAM,0CAA0C,CAAC;AAChG,OAAO,EAAE,gBAAgB,EAAE,KAAK,qBAAqB,EAAE,MAAM,8CAA8C,CAAC;AAC5G,OAAO,EAAE,uBAAuB,EAAE,KAAK,iBAAiB,EAAE,MAAM,iCAAiC,CAAC"}

package/dist/routes/rules/datalog-editor.js

@@ -0,0 +1,7 @@
+// The panels around the Datalog editor, which hold no CodeMirror of their own. The editor that
+// composes them stays in `agents` with the CodeMirror stack.
+export { BindingsPreview } from "./components/datalog-editor/BindingsPreview.js";
+export { FactsPreview } from "./components/datalog-editor/FactsPreview.js";
+export { PreviewPanel } from "./components/datalog-editor/PreviewPanel.js";
+export { SparqlQueryPanel } from "./components/datalog-editor/SparqlQueryPanel.js";
+export { useSparqlQueryExecution } from "./hooks/useSparqlQueryExecution.js";

package/dist/routes/rules/hooks/useRuleFactsPreview.d.ts

@@ -0,0 +1,53 @@
+import type { GraphQLClient } from "graphql-request";
+type Triple = {
+    subject: string;
+    predicate: string;
+    object: string;
+};
+type UseRuleFactsPreviewOptions = {
+    rule: string;
+    graphqlClient?: GraphQLClient;
+    prefixes?: Record<string, string>;
+    enabled?: boolean;
+    sampleLimit?: number;
+};
+type UseRuleFactsPreviewResult = {
+    factCount: number | null;
+    samples: Triple[] | null;
+    isLoadingCount: boolean;
+    isLoadingSamples: boolean;
+    error: string | null;
+};
+export declare function useRuleFactsPreview(options: UseRuleFactsPreviewOptions): UseRuleFactsPreviewResult;
+export type PropertyAtom = {
+    type: "property";
+    predicate: {
+        value: string;
+    };
+    arguments: Array<{
+        value: string;
+    }>;
+};
+export type ClassAtom = {
+    type: "class";
+    predicate: {
+        value: string;
+    };
+    arguments: Array<{
+        value: string;
+    }>;
+};
+export type TripleAtom = {
+    type: "triple";
+    subject: {
+        value: string;
+    };
+    predicate: {
+        value: string;
+    };
+    object: {
+        value: string;
+    };
+};
+export {};
+//# sourceMappingURL=useRuleFactsPreview.d.ts.map

package/dist/routes/rules/hooks/useRuleFactsPreview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRuleFactsPreview.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/hooks/useRuleFactsPreview.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIrD,KAAK,MAAM,GAAG;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAkBF,KAAK,yBAAyB,GAAG;IAC/B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACzB,cAAc,EAAE,OAAO,CAAC;IACxB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,GAAG,yBAAyB,CA+HlG;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,UAAU,CAAC;IACjB,SAAS,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7B,SAAS,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7B,SAAS,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3B,SAAS,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7B,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3B,CAAC"}

package/dist/routes/rules/hooks/useRuleFactsPreview.js

@@ -0,0 +1,214 @@
+import { useSparqlQueryQuery } from "@manta-eu/client";
+import { formatIriForRdfox, compactUri, namespaces } from "@manta-eu/client/shared/rdf-namespaces";
+import { isJsonLdNode } from "@manta-eu/client/types/jsonld";
+import { parseDatalogRule, datalogBodyToSparqlSelect } from "@manta-eu/datalog-parser";
+import { isPresent } from "@manta-eu/lib/present";
+import { useState, useEffect, useMemo } from "react";
+import { match } from "ts-pattern";
+function sparqlConstructQuery(args) {
+    const { constructPatterns, sampleLimit, whereClause } = args;
+    return `CONSTRUCT { ${constructPatterns} } WHERE { ${whereClause} }} LIMIT ${sampleLimit}`;
+}
+function sparqlCountQuery(args) {
+    const { sparql, whereClause } = args;
+    return `SELECT (COUNT(*) as ?count)
+          WHERE {
+            SELECT DISTINCT ${sparql.variables.map((v) => `?${v}`).join(" ")}
+            WHERE {
+              ${whereClause}
+            }
+          }`;
+}
+export function useRuleFactsPreview(options) {
+    const { rule, graphqlClient, prefixes = namespaces, enabled = true, sampleLimit = 10 } = options;
+    const [factCount, setFactCount] = useState(null);
+    const [samples, setSamples] = useState(null);
+    const [isLoadingCount, setIsLoadingCount] = useState(false);
+    const [isLoadingSamples, setIsLoadingSamples] = useState(false);
+    const [error, setError] = useState(null);
+    const [currentCountQuery, setCurrentCountQuery] = useState(null);
+    const [currentSampleQuery, setCurrentSampleQuery] = useState(null);
+    const { constructQuery, countQuery, parseError } = useMemo(() => {
+        if (!rule || !enabled) {
+            return { constructQuery: null, countQuery: null, parseError: null };
+        }
+        try {
+            const ast = parseDatalogRule(rule);
+            if (!isPresent(ast.head) || !isPresent(ast.body)) {
+                return { constructQuery: null, countQuery: null, parseError: null };
+            }
+            const sparqlSelect = datalogBodyToSparqlSelect(ast.body, prefixes);
+            const whereStartIndex = sparqlSelect.query.indexOf("WHERE {");
+            const whereEndIndex = sparqlSelect.query.lastIndexOf("}");
+            const whereClause = whereStartIndex !== -1 && whereEndIndex > whereStartIndex
+                ? sparqlSelect.query.substring(whereStartIndex + 7, whereEndIndex).trim()
+                : "";
+            const constructPatterns = ast.head
+                .map((atom) => {
+                return generateTriplePattern(atom);
+            })
+                .filter(Boolean)
+                .join(" .\n  ");
+            const query = sparqlConstructQuery({ constructPatterns, sampleLimit, whereClause });
+            const countQuery = sparqlCountQuery({ sparql: sparqlSelect, whereClause });
+            return { constructQuery: query, countQuery, parseError: null };
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : "Failed to generate queries";
+            return { constructQuery: null, countQuery: null, parseError: errorMessage };
+        }
+    }, [rule, enabled, prefixes, sampleLimit]);
+    useEffect(() => {
+        if (parseError) {
+            setError(parseError);
+        }
+        else {
+            setError(null);
+        }
+    }, [parseError]);
+    useEffect(() => {
+        setCurrentCountQuery(countQuery);
+    }, [countQuery]);
+    useEffect(() => {
+        setCurrentSampleQuery(constructQuery);
+    }, [constructQuery]);
+    const countQueryResult = useSparqlQueryQuery(graphqlClient, { query: currentCountQuery || "" }, {
+        enabled: Boolean(currentCountQuery && graphqlClient && enabled),
+    });
+    useEffect(() => {
+        setIsLoadingCount(countQueryResult.isLoading);
+        if (countQueryResult.error) {
+            setError(countQueryResult.error instanceof Error ? countQueryResult.error.message : "Failed to count facts");
+            setFactCount(null);
+        }
+        else if (countQueryResult.data?.sparqlQuery) {
+            const result = countQueryResult.data.sparqlQuery;
+            if (result.error) {
+                setError(result.error);
+                setFactCount(null);
+            }
+            else if (result.results) {
+                const bindings = result.results.results?.bindings || [];
+                const countBinding = bindings[0] && typeof bindings[0] === "object" && "count" in bindings[0]
+                    ? bindings[0].count
+                    : undefined;
+                const count = countBinding ? parseInt(countBinding.value, 10) : 0;
+                setFactCount(count);
+            }
+        }
+    }, [countQueryResult]);
+    const sampleQueryResult = useSparqlQueryQuery(graphqlClient, { query: currentSampleQuery || "" }, {
+        enabled: Boolean(currentSampleQuery && graphqlClient && enabled && factCount && factCount > 0),
+    });
+    useEffect(() => {
+        setIsLoadingSamples(sampleQueryResult.isLoading);
+        if (!sampleQueryResult.data?.sparqlQuery || factCount === 0 || factCount === null) {
+            setSamples(null);
+        }
+        else {
+            const result = sampleQueryResult.data.sparqlQuery;
+            if (result.error) {
+                setSamples(null);
+            }
+            else if (result.graph) {
+                const triples = parseGraphToTriples(result.graph);
+                setSamples(triples);
+            }
+        }
+    }, [sampleQueryResult, factCount, prefixes]);
+    return {
+        factCount,
+        samples,
+        isLoadingCount,
+        isLoadingSamples,
+        error,
+    };
+}
+function isPropertyAtom(atom) {
+    return (atom.type === "property" &&
+        "predicate" in atom &&
+        "arguments" in atom &&
+        typeof atom.predicate === "object" &&
+        atom.predicate !== null &&
+        "value" in atom.predicate &&
+        Array.isArray(atom.arguments));
+}
+function isClassAtom(atom) {
+    return (atom.type === "class" &&
+        "predicate" in atom &&
+        "arguments" in atom &&
+        typeof atom.predicate === "object" &&
+        atom.predicate !== null &&
+        "value" in atom.predicate &&
+        Array.isArray(atom.arguments));
+}
+function isTripleAtom(atom) {
+    return (atom.type === "triple" &&
+        "subject" in atom &&
+        "predicate" in atom &&
+        "object" in atom &&
+        typeof atom.subject === "object" &&
+        atom.subject !== null &&
+        "value" in atom.subject &&
+        typeof atom.predicate === "object" &&
+        atom.predicate !== null &&
+        "value" in atom.predicate &&
+        typeof atom.object === "object" &&
+        atom.object !== null &&
+        "value" in atom.object);
+}
+function generateTriplePattern(atom) {
+    return match(atom.type)
+        .with("property", () => {
+        if (!isPropertyAtom(atom))
+            return null;
+        const subject = atom.arguments[0]?.value || "?s";
+        const predicate = formatIriForRdfox(atom.predicate.value || "");
+        const object = atom.arguments[1]?.value || "?o";
+        return `${subject} ${predicate} ${object}`;
+    })
+        .with("class", () => {
+        if (!isClassAtom(atom))
+            return null;
+        const subject = atom.arguments[0]?.value || "?s";
+        const classIRI = formatIriForRdfox(atom.predicate.value || "");
+        return `${subject} a ${classIRI}`;
+    })
+        .with("triple", () => {
+        if (!isTripleAtom(atom))
+            return null;
+        const subject = atom.subject.value || "?s";
+        const predicate = formatIriForRdfox(atom.predicate.value || "");
+        const object = atom.object.value || "?o";
+        return `${subject} ${predicate} ${object}`;
+    })
+        .otherwise(() => null);
+}
+function parseGraphToTriples(graph) {
+    const triples = [];
+    if (!Array.isArray(graph))
+        return triples;
+    for (const node of graph) {
+        if (!isJsonLdNode(node))
+            continue;
+        const subject = compactUri(String(node["@id"] || ""));
+        for (const [key, value] of Object.entries(node)) {
+            if (key === "@id")
+                continue;
+            const predicate = key === "@type" ? "a" : compactUri(key);
+            if (Array.isArray(value)) {
+                for (const v of value) {
+                    const object = typeof v === "object" && v !== null && "@id" in v ? compactUri(String(v["@id"])) : String(v);
+                    triples.push({ subject, predicate, object });
+                }
+            }
+            else if (value) {
+                const object = typeof value === "object" && value !== null && "@id" in value
+                    ? compactUri(String(value["@id"]))
+                    : String(value);
+                triples.push({ subject, predicate, object });
+            }
+        }
+    }
+    return triples;
+}