@manta-eu/react 0.1.0

package/dist/routes/plans/components/actionPlansTableConfig.d.ts

@@ -0,0 +1,105 @@
+import { GQLActionPlanOrderField, GQLActionPlanState, GQLOrderDirection } from "@manta-eu/client";
+import type { SortingState } from "@tanstack/react-table";
+import type { ActionPlansApprovalFilter } from "#ldo-ui";
+declare const statusFilterValues: readonly ["ALL", "READY", "RUNNING", "FAILED", "TIMED_OUT", "COMPLETED"];
+export type StatusFilter = (typeof statusFilterValues)[number];
+export declare const tableKey = "action-plans-table";
+export declare const actionPlanColumnIds: {
+    readonly name: "name";
+    readonly state: "state";
+    readonly updatedAt: "updatedAt";
+    readonly lastRunAt: "lastRunAt";
+    readonly pendingApprovals: "pendingApprovals";
+    readonly type: "type";
+    readonly actions: "actions";
+};
+export declare const actionPlanColumnLabels: {
+    name: string;
+    state: string;
+    updatedAt: string;
+    lastRunAt: string;
+    pendingApprovals: string;
+    type: string;
+};
+export declare const statusFilterOptions: {
+    id: StatusFilter;
+    label: string;
+    dotClass: string;
+}[];
+export declare const defaultColumnOrder: ("name" | "type" | "actions" | "state" | "updatedAt" | "lastRunAt" | "pendingApprovals")[];
+export declare const parseAsStatusFilter: Omit<import("nuqs").SingleParserBuilder<"RUNNING" | "FAILED" | "TIMED_OUT" | "COMPLETED" | "ALL" | "READY">, "parseServerSide"> & {
+    readonly defaultValue: NonNullable<"RUNNING" | "FAILED" | "TIMED_OUT" | "COMPLETED" | "ALL" | "READY">;
+    parseServerSide(value: string | string[] | undefined): NonNullable<"RUNNING" | "FAILED" | "TIMED_OUT" | "COMPLETED" | "ALL" | "READY">;
+};
+export declare const availabilityFilterOptions: readonly [{
+    readonly id: "CURRENT";
+    readonly label: "Current plans";
+}, {
+    readonly id: "PAST_RUNS_ONLY";
+    readonly label: "History-only plans";
+}, {
+    readonly id: "ALL";
+    readonly label: "All plans";
+}];
+export type AvailabilityFilter = (typeof availabilityFilterOptions)[number]["id"];
+export declare const parseAsAvailabilityFilter: Omit<import("nuqs").SingleParserBuilder<"CURRENT" | "PAST_RUNS_ONLY" | "ALL">, "parseServerSide"> & {
+    readonly defaultValue: NonNullable<"CURRENT" | "PAST_RUNS_ONLY" | "ALL">;
+    parseServerSide(value: string | string[] | undefined): NonNullable<"CURRENT" | "PAST_RUNS_ONLY" | "ALL">;
+};
+export declare function planFiltersForSelection(statusFilter: StatusFilter, availability: AvailabilityFilter): {
+    states: GQLActionPlanState[] | undefined;
+    availability: AvailabilityFilter;
+};
+export declare const typeFilterOptions: readonly [{
+    readonly id: "GOOGLE";
+    readonly label: "Google";
+}, {
+    readonly id: "META";
+    readonly label: "Meta";
+}, {
+    readonly id: "LINKEDIN";
+    readonly label: "LinkedIn";
+}, {
+    readonly id: "SHOPIFY";
+    readonly label: "Shopify";
+}, {
+    readonly id: "SNAPCHAT";
+    readonly label: "Snapchat";
+}, {
+    readonly id: "WOOCOMMERCE";
+    readonly label: "WooCommerce";
+}, {
+    readonly id: "NONE";
+    readonly label: "None";
+}];
+export type TypeFilter = (typeof typeFilterOptions)[number]["id"];
+export declare const parseAsTypeFilter: Omit<import("nuqs").SingleParserBuilder<("META" | "SNAPCHAT" | "SHOPIFY" | "GOOGLE" | "NONE" | "LINKEDIN" | "WOOCOMMERCE")[]>, "parseServerSide"> & {
+    readonly defaultValue: ("META" | "SNAPCHAT" | "SHOPIFY" | "GOOGLE" | "NONE" | "LINKEDIN" | "WOOCOMMERCE")[];
+    parseServerSide(value: string | string[] | undefined): ("META" | "SNAPCHAT" | "SHOPIFY" | "GOOGLE" | "NONE" | "LINKEDIN" | "WOOCOMMERCE")[];
+};
+export declare const approvalFilterOptions: readonly [{
+    readonly id: "ALL";
+    readonly label: "All";
+}, {
+    readonly id: "NEEDS_APPROVAL";
+    readonly label: "Needs approval";
+}, {
+    readonly id: "NO_PENDING";
+    readonly label: "No pending approvals";
+}];
+export type ApprovalFilter = (typeof approvalFilterOptions)[number]["id"];
+export declare const parseAsApprovalFilter: Omit<import("nuqs").SingleParserBuilder<"NEEDS_APPROVAL" | "NO_PENDING" | "ALL">, "parseServerSide"> & {
+    readonly defaultValue: NonNullable<"NEEDS_APPROVAL" | "NO_PENDING" | "ALL">;
+    parseServerSide(value: string | string[] | undefined): NonNullable<"NEEDS_APPROVAL" | "NO_PENDING" | "ALL">;
+};
+export declare const parseAsPlanSearch: Omit<import("nuqs").SingleParserBuilder<string>, "parseServerSide"> & {
+    readonly defaultValue: string;
+    parseServerSide(value: string | string[] | undefined): string;
+};
+export declare function approvalForFilter(filter: ApprovalFilter): ActionPlansApprovalFilter | undefined;
+export declare function orderByForSorting(sorting: SortingState): {
+    field: GQLActionPlanOrderField;
+    direction: GQLOrderDirection;
+};
+export {};
+//# sourceMappingURL=actionPlansTableConfig.d.ts.map

package/dist/routes/plans/components/actionPlansTableConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actionPlansTableConfig.d.ts","sourceRoot":"","sources":["../../../../src/routes/plans/components/actionPlansTableConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAClG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG1D,OAAO,KAAK,EAA+B,yBAAyB,EAAiC,MAAM,SAAS,CAAC;AAErH,QAAA,MAAM,kBAAkB,0EAA2E,CAAC;AAEpG,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/D,eAAO,MAAM,QAAQ,uBAAuB,CAAC;AAI7C,eAAO,MAAM,mBAAmB;;;;;;;;CAQtB,CAAC;AAMX,eAAO,MAAM,sBAAsB;;;;;;;CAOkB,CAAC;AAEtD,eAAO,MAAM,mBAAmB,EAAE;IAAE,EAAE,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,EAOtF,CAAC;AAEF,eAAO,MAAM,kBAAkB,4FAAqC,CAAC;AAErE,eAAO,MAAM,mBAAmB;;;CAA8E,CAAC;AAE/G,eAAO,MAAM,yBAAyB;;;;;;;;;EAI8C,CAAC;AAErF,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC;AAElF,eAAO,MAAM,yBAAyB;;;CAEd,CAAC;AAWzB,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,YAAY,EAC1B,YAAY,EAAE,kBAAkB,GAC/B;IAAE,MAAM,EAAE,kBAAkB,EAAE,GAAG,SAAS,CAAC;IAAC,YAAY,EAAE,kBAAkB,CAAA;CAAE,CAQhF;AAED,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;EAQoD,CAAC;AAEnF,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC;AAElE,eAAO,MAAM,iBAAiB;;;CAEb,CAAC;AAElB,eAAO,MAAM,qBAAqB;;;;;;;;;EAIxB,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC;AAE1E,eAAO,MAAM,qBAAqB;;;CAEd,CAAC;AAErB,eAAO,MAAM,iBAAiB;;;CAAgC,CAAC;AAE/D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,cAAc,GAAG,yBAAyB,GAAG,SAAS,CAE/F;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,YAAY;;;EAMtD"}

package/dist/routes/plans/components/actionPlansTableConfig.js

@@ -0,0 +1,82 @@
+import { GQLActionPlanOrderField, GQLActionPlanState, GQLOrderDirection } from "@manta-eu/client";
+import { parseAsArrayOf, parseAsString, parseAsStringEnum } from "nuqs";
+import { match } from "ts-pattern";
+const statusFilterValues = ["ALL", "READY", "RUNNING", "FAILED", "TIMED_OUT", "COMPLETED"];
+export const tableKey = "action-plans-table";
+const allPlanStates = Object.values(GQLActionPlanState);
+export const actionPlanColumnIds = {
+    name: "name",
+    state: "state",
+    updatedAt: "updatedAt",
+    lastRunAt: "lastRunAt",
+    pendingApprovals: "pendingApprovals",
+    type: "type",
+    actions: "actions",
+};
+export const actionPlanColumnLabels = {
+    [actionPlanColumnIds.name]: "Name",
+    [actionPlanColumnIds.state]: "State",
+    [actionPlanColumnIds.updatedAt]: "Updated at",
+    [actionPlanColumnIds.lastRunAt]: "Last run",
+    [actionPlanColumnIds.pendingApprovals]: "Pending approvals",
+    [actionPlanColumnIds.type]: "Type",
+};
+export const statusFilterOptions = [
+    { id: "ALL", label: "All", dotClass: "bg-transparent" },
+    { id: "READY", label: "Ready", dotClass: "bg-muted-foreground" },
+    { id: "RUNNING", label: "Running", dotClass: "bg-warning-foreground" },
+    { id: "FAILED", label: "Failed", dotClass: "bg-error-foreground" },
+    { id: "TIMED_OUT", label: "Timed out", dotClass: "bg-warning-foreground" },
+    { id: "COMPLETED", label: "Completed", dotClass: "bg-success-foreground" },
+];
+export const defaultColumnOrder = Object.values(actionPlanColumnIds);
+export const parseAsStatusFilter = parseAsStringEnum([...statusFilterValues]).withDefault("ALL");
+export const availabilityFilterOptions = [
+    { id: "CURRENT", label: "Current plans" },
+    { id: "PAST_RUNS_ONLY", label: "History-only plans" },
+    { id: "ALL", label: "All plans" },
+];
+export const parseAsAvailabilityFilter = parseAsStringEnum(availabilityFilterOptions.map((option) => option.id)).withDefault("CURRENT");
+const statesByStatusFilter = {
+    ALL: allPlanStates,
+    READY: [GQLActionPlanState.Draft],
+    RUNNING: [GQLActionPlanState.Running],
+    FAILED: [GQLActionPlanState.Failed],
+    TIMED_OUT: [GQLActionPlanState.TimedOut],
+    COMPLETED: [GQLActionPlanState.Completed],
+};
+export function planFiltersForSelection(statusFilter, availability) {
+    const selectedStates = statesByStatusFilter[statusFilter];
+    const states = selectedStates.length === allPlanStates.length ? undefined : selectedStates;
+    return match({ statusFilter, availability })
+        .with({ statusFilter: "READY", availability: "PAST_RUNS_ONLY" }, () => ({ states: [], availability }))
+        .with({ statusFilter: "READY" }, () => ({ states, availability: "CURRENT" }))
+        .otherwise(() => ({ states, availability }));
+}
+export const typeFilterOptions = [
+    { id: "GOOGLE", label: "Google" },
+    { id: "META", label: "Meta" },
+    { id: "LINKEDIN", label: "LinkedIn" },
+    { id: "SHOPIFY", label: "Shopify" },
+    { id: "SNAPCHAT", label: "Snapchat" },
+    { id: "WOOCOMMERCE", label: "WooCommerce" },
+    { id: "NONE", label: "None" },
+];
+export const parseAsTypeFilter = parseAsArrayOf(parseAsStringEnum(typeFilterOptions.map((option) => option.id))).withDefault([]);
+export const approvalFilterOptions = [
+    { id: "ALL", label: "All" },
+    { id: "NEEDS_APPROVAL", label: "Needs approval" },
+    { id: "NO_PENDING", label: "No pending approvals" },
+];
+export const parseAsApprovalFilter = parseAsStringEnum(approvalFilterOptions.map((option) => option.id)).withDefault("ALL");
+export const parseAsPlanSearch = parseAsString.withDefault("");
+export function approvalForFilter(filter) {
+    return filter === "ALL" ? undefined : filter;
+}
+export function orderByForSorting(sorting) {
+    const stateSort = sorting.find((sort) => sort.id === actionPlanColumnIds.state);
+    return {
+        field: GQLActionPlanOrderField.State,
+        direction: stateSort?.desc === false ? GQLOrderDirection.Asc : GQLOrderDirection.Desc,
+    };
+}

package/dist/routes/plans/components/frame.d.ts

@@ -0,0 +1,27 @@
+import type { ElementType, ReactNode } from "react";
+export type ActionPlanLinkProps = {
+    href?: string;
+    to?: string;
+    className?: string;
+    children?: ReactNode;
+};
+export type ActionPlanLinkComponent = ElementType;
+export type ActionPlansFrameProps = {
+    header: ReactNode;
+    filters: ReactNode;
+    body: ReactNode;
+};
+export type ActionPlanFrameProps = {
+    header: ReactNode;
+    body: ReactNode;
+};
+type SurfaceContainerProps = {
+    children: ReactNode;
+    width?: "wide" | "v4";
+    padding?: boolean;
+};
+export declare function SurfaceContainer(props: SurfaceContainerProps): import("react/jsx-runtime").JSX.Element;
+export declare function renderDefaultActionPlansFrame(props: ActionPlansFrameProps): import("react/jsx-runtime").JSX.Element;
+export declare function renderDefaultActionPlanFrame(props: ActionPlanFrameProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=frame.d.ts.map

package/dist/routes/plans/components/frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame.d.ts","sourceRoot":"","sources":["../../../../src/routes/plans/components/frame.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIpD,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,WAAW,CAAC;AAElD,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,SAAS,CAAC;IAClB,OAAO,EAAE,SAAS,CAAC;IACnB,IAAI,EAAE,SAAS,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,SAAS,CAAC;IAClB,IAAI,EAAE,SAAS,CAAC;CACjB,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,QAAQ,EAAE,SAAS,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,2CAgB5D;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,qBAAqB,2CAEzE;AAYD,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,oBAAoB,2CAEvE"}

package/dist/routes/plans/components/frame.js

@@ -0,0 +1,22 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { MainContent } from "#components/main-content/index";
+import { cn } from "#lib/utils";
+export function SurfaceContainer(props) {
+    const { children, width = "v4", padding = true } = props;
+    return (_jsx("div", { className: cn("px-6 py-6 lg:py-4", width === "v4" && "p-6 lg:p-10", !padding && "p-0"), children: _jsx("div", { className: cn("mx-auto flex w-full flex-col gap-6", width === "wide" && "max-w-7xl", width === "v4" && "max-w-7xl"), children: children }) }));
+}
+export function renderDefaultActionPlansFrame(props) {
+    return _jsx(DefaultActionPlansFrame, { ...props });
+}
+function DefaultActionPlansFrame(props) {
+    const { header, filters, body } = props;
+    return (_jsx(MainContent, { fullPage: true, header: header, filters: filters, children: body }));
+}
+export function renderDefaultActionPlanFrame(props) {
+    return _jsx(DefaultActionPlanFrame, { ...props });
+}
+function DefaultActionPlanFrame(props) {
+    const { header, body } = props;
+    return (_jsx(MainContent, { header: header, children: _jsx(SurfaceContainer, { width: "wide", padding: false, children: body }) }));
+}

package/dist/routes/plans/hooks/useActionPlanRouteState.d.ts

@@ -0,0 +1,6 @@
+export type ActionPlanPageMode = "planning" | "actioning";
+export declare function useActionPlanRouteState(): {
+    planName: string | undefined;
+    initialMode: ActionPlanPageMode;
+};
+//# sourceMappingURL=useActionPlanRouteState.d.ts.map

package/dist/routes/plans/hooks/useActionPlanRouteState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActionPlanRouteState.d.ts","sourceRoot":"","sources":["../../../../src/routes/plans/hooks/useActionPlanRouteState.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,kBAAkB,GAAG,UAAU,GAAG,WAAW,CAAC;AAE1D,wBAAgB,uBAAuB,IAAI;IACzC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,WAAW,EAAE,kBAAkB,CAAC;CACjC,CAOA"}

package/dist/routes/plans/hooks/useActionPlanRouteState.js

@@ -0,0 +1,9 @@
+"use client";
+import { useParams } from "react-router";
+export function useActionPlanRouteState() {
+    const { planName } = useParams();
+    return {
+        planName,
+        initialMode: "planning",
+    };
+}

package/dist/routes/plans/index.d.ts

@@ -0,0 +1,7 @@
+export { ActionPlanPage, type ActionPlanPageProps } from "./components/ActionPlanPage.js";
+export { ActionPlansPage, type ActionPlansPageProps } from "./components/ActionPlansPage.js";
+export { PlanDetailRouteContent, type PlanDetailRouteContentProps } from "./components/PlanDetailRouteContent.js";
+export { useActionPlanRouteState } from "./hooks/useActionPlanRouteState.js";
+export type { ActionPlanFrameProps, ActionPlansFrameProps, ActionPlanLinkComponent, ActionPlanLinkProps, } from "./components/frame.js";
+export declare function PlansRoute(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/routes/plans/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/routes/plans/index.tsx"],"names":[],"mappings":"AAUA,OAAO,EAAE,cAAc,EAAE,KAAK,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACvF,OAAO,EAAE,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAC1F,OAAO,EAAE,sBAAsB,EAAE,KAAK,2BAA2B,EAAE,MAAM,qCAAqC,CAAC;AAC/G,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,YAAY,EACV,oBAAoB,EACpB,qBAAqB,EACrB,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,oBAAoB,CAAC;AAY5B,wBAAgB,UAAU,4CAyBzB"}

package/dist/routes/plans/index.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Zap } from "lucide-react";
+import { useMemo } from "react";
+import { ActionPlansPage } from "./components/ActionPlansPage.js";
+import { PlanDetailRouteContent } from "./components/PlanDetailRouteContent.js";
+import { useActionPlanRouteState } from "./hooks/useActionPlanRouteState.js";
+import { PageBody, PageHeader } from "#components/layouts/page/index";
+import { RouteLayout } from "#components/layouts/RouteLayout";
+import { useAuthContext } from "#providers/AuthContext";
+export { ActionPlanPage } from "./components/ActionPlanPage.js";
+export { ActionPlansPage } from "./components/ActionPlansPage.js";
+export { PlanDetailRouteContent } from "./components/PlanDetailRouteContent.js";
+export { useActionPlanRouteState } from "./hooks/useActionPlanRouteState.js";
+function renderActionPlansRouteLayout(props) {
+    return (_jsxs(_Fragment, { children: [_jsx(PageHeader, { title: "Action Plans", icon: Zap }), _jsx("div", { className: "border-b border-muted-border px-5 py-3 shrink-0", children: props.filters }), _jsx(PageBody, { className: "flex min-h-0 flex-col", children: props.body })] }));
+}
+export function PlansRoute() {
+    const { datastore, datastores, user, logout, isOperator, canSwitchDatastore, allowedModels } = useAuthContext();
+    const { planName } = useActionPlanRouteState();
+    const routeContent = useMemo(() => {
+        if (!planName) {
+            return _jsx(ActionPlansPage, { renderLayout: renderActionPlansRouteLayout });
+        }
+        return _jsx(StandalonePlanDetailRoute, { planName: planName, datastoreId: datastore?.id, userId: user.id });
+    }, [planName, datastore?.id, user.id]);
+    return (_jsx(RouteLayout, { user: user, datastore: datastore, datastores: datastores, isOperator: isOperator, canSwitchDatastore: canSwitchDatastore, logout: logout, allowedModels: allowedModels, children: routeContent }));
+}
+function StandalonePlanDetailRoute(props) {
+    const { planName, datastoreId, userId } = props;
+    return _jsx(PlanDetailRouteContent, { planName: planName, datastoreId: datastoreId, userId: userId });
+}

package/dist/routes/rules/components/InlineMeta.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentProps, ReactNode, Ref } from "react";
+export type InlineMetaProps = ComponentProps<"span"> & {
+    icon: ReactNode;
+    ref?: Ref<HTMLSpanElement>;
+};
+export declare function InlineMeta(props: InlineMetaProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=InlineMeta.d.ts.map

package/dist/routes/rules/components/InlineMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InlineMeta.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/InlineMeta.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAG5D,MAAM,MAAM,eAAe,GAAG,cAAc,CAAC,MAAM,CAAC,GAAG;IACrD,IAAI,EAAE,SAAS,CAAC;IAChB,GAAG,CAAC,EAAE,GAAG,CAAC,eAAe,CAAC,CAAC;CAC5B,CAAC;AAEF,wBAAgB,UAAU,CAAC,KAAK,EAAE,eAAe,2CAYhD"}

package/dist/routes/rules/components/InlineMeta.js

@@ -0,0 +1,6 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { cn } from "#lib/utils";
+export function InlineMeta(props) {
+    const { icon, className, children, ref, ...restProps } = props;
+    return (_jsxs("span", { ref: ref, className: cn("inline-flex items-center gap-1.5 typography-caption text-muted-foreground", className), ...restProps, children: [icon, children] }));
+}

package/dist/routes/rules/components/RuleOwnershipBadge.d.ts

@@ -0,0 +1,9 @@
+import type { GQLRuleOwnership } from "@manta-eu/client";
+import type { ComponentProps } from "react";
+export type RuleOwnershipBadgeProps = ComponentProps<"span"> & {
+    ownership: GQLRuleOwnership | null;
+    ownerName?: string | null;
+    appearance?: "badge" | "inline";
+};
+export declare function RuleOwnershipBadge(props: RuleOwnershipBadgeProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=RuleOwnershipBadge.d.ts.map

package/dist/routes/rules/components/RuleOwnershipBadge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleOwnershipBadge.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/RuleOwnershipBadge.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAK5C,MAAM,MAAM,uBAAuB,GAAG,cAAc,CAAC,MAAM,CAAC,GAAG;IAC7D,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACnC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,UAAU,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;CACjC,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,uBAAuB,kDA4BhE"}

package/dist/routes/rules/components/RuleOwnershipBadge.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { User } from "lucide-react";
+import { InlineMeta } from "./InlineMeta.js";
+import { Badge } from "#components/badge/index";
+import { MantaLogo } from "#components/manta-logo/index";
+export function RuleOwnershipBadge(props) {
+    const { ownership, ownerName, appearance = "badge", className, ...restProps } = props;
+    if (!ownership) {
+        return null;
+    }
+    const isManta = ownership.type === "MANTA";
+    const label = isManta ? "Manta" : ownerName || "User";
+    if (appearance === "inline") {
+        return (_jsx(InlineMeta, { icon: isManta ? _jsx(MantaLogo, { size: 12, className: "text-muted-foreground" }) : _jsx(User, { className: "size-3.5" }), className: className, ...restProps, children: label }));
+    }
+    return (_jsxs(Badge, { variant: "secondary", size: "sm", className: className, ...restProps, children: [isManta ? _jsx(MantaLogo, { size: 12 }) : _jsx(User, {}), label] }));
+}

package/dist/routes/rules/components/RuleSetup.d.ts

@@ -0,0 +1,9 @@
+import type { Awaitable } from "@manta-eu/lib/types";
+import { type RenderTermProducers } from "#ldo-ui";
+export type RuleSetupProps = {
+    ruleText: string;
+    onStageChange?: (newRuleText: string) => Awaitable<boolean>;
+    renderTermProducers?: RenderTermProducers;
+};
+export declare function RuleSetup(props: RuleSetupProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RuleSetup.d.ts.map

package/dist/routes/rules/components/RuleSetup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleSetup.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/RuleSetup.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAIrD,OAAO,EAA+C,KAAK,mBAAmB,EAAiB,MAAM,SAAS,CAAC;AAE/G,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,SAAS,CAAC,OAAO,CAAC,CAAC;IAC5D,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;CAC3C,CAAC;AAEF,wBAAgB,SAAS,CAAC,KAAK,EAAE,cAAc,2CA8B9C"}

package/dist/routes/rules/components/RuleSetup.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { isPresent } from "@manta-eu/lib/present";
+import { useMemo } from "react";
+import { RuleValueControls } from "./RuleValueControls.js";
+import { Banner } from "#components/banner/index";
+import { buildRuleSetupModel, parseDatalogRuleCached, RuleNarrative } from "#ldo-ui";
+export function RuleSetup(props) {
+    const { ruleText, onStageChange, renderTermProducers } = props;
+    const isEmpty = !isPresent(ruleText);
+    const { ast, error } = useMemo(() => {
+        if (isEmpty)
+            return { ast: null, error: null };
+        return parseDatalogRuleCached(ruleText);
+    }, [ruleText, isEmpty]);
+    const model = useMemo(() => (ast ? buildRuleSetupModel(ast) : null), [ast]);
+    if (isEmpty) {
+        return _jsx("div", { className: "typography-small text-muted-foreground", children: "No rule to display" });
+    }
+    if (!model) {
+        return (_jsxs("div", { className: "flex flex-col gap-2", children: [_jsx(Banner, { label: `Could not parse rule: ${error}` }), _jsx("pre", { className: "overflow-x-auto whitespace-pre-wrap rounded-md bg-faint p-3 font-mono typography-caption text-muted-foreground", children: ruleText })] }));
+    }
+    return (_jsxs(_Fragment, { children: [_jsx(RuleNarrative, { model: model, renderTermProducers: renderTermProducers }), onStageChange && _jsx(RuleValueControls, { model: model, onStageChange: onStageChange })] }));
+}

package/dist/routes/rules/components/RuleStatusBadge.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentProps } from "react";
+import type { RuleStatus } from "./rules.utils.js";
+export type RuleStatusBadgeProps = ComponentProps<"span"> & {
+    status: RuleStatus;
+    appearance?: "badge" | "inline";
+};
+export declare function RuleStatusBadge(props: RuleStatusBadgeProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=RuleStatusBadge.d.ts.map

package/dist/routes/rules/components/RuleStatusBadge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleStatusBadge.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/RuleStatusBadge.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,OAAO,CAAC;AAE5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGhD,MAAM,MAAM,oBAAoB,GAAG,cAAc,CAAC,MAAM,CAAC,GAAG;IAC1D,MAAM,EAAE,UAAU,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;CACjC,CAAC;AASF,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,2CAkB1D"}

package/dist/routes/rules/components/RuleStatusBadge.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CheckCircle2, CirclePlus, Pencil, Trash2 } from "lucide-react";
+import { InlineMeta } from "./InlineMeta.js";
+import { Badge } from "#components/badge/index";
+const statusConfig = {
+    committed: { label: "Committed", variant: "secondary", icon: CheckCircle2 },
+    new: { label: "New", variant: "info", icon: CirclePlus },
+    modified: { label: "Modified", variant: "warning", icon: Pencil },
+    deleted: { label: "Deleted", variant: "destructive", icon: Trash2 },
+};
+export function RuleStatusBadge(props) {
+    const { status, appearance = "badge", className, ...restProps } = props;
+    const config = statusConfig[status];
+    const Icon = config.icon;
+    if (appearance === "inline") {
+        return (_jsx(InlineMeta, { icon: _jsx(Icon, { className: "size-3.5" }), className: className, ...restProps, children: config.label }));
+    }
+    return (_jsx(Badge, { variant: config.variant, size: "sm", className: className, ...restProps, children: config.label }));
+}

package/dist/routes/rules/components/RuleValueControls.d.ts

@@ -0,0 +1,8 @@
+import type { Awaitable } from "@manta-eu/lib/types";
+import { type RuleSetupModel } from "#ldo-ui";
+export type RuleValueControlsProps = {
+    model: RuleSetupModel;
+    onStageChange: (newRuleText: string) => Awaitable<boolean>;
+};
+export declare function RuleValueControls(props: RuleValueControlsProps): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=RuleValueControls.d.ts.map

package/dist/routes/rules/components/RuleValueControls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuleValueControls.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/RuleValueControls.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAOrD,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,SAAS,CAAC;AAiCjB,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,cAAc,CAAC;IACtB,aAAa,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,SAAS,CAAC,OAAO,CAAC,CAAC;CAC5D,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,kDAgG9D"}

package/dist/routes/rules/components/RuleValueControls.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { isPresent } from "@manta-eu/lib/present";
+import { RotateCcw, Save, SlidersHorizontal } from "lucide-react";
+import { identity } from "ramda";
+import { useEffect, useId, useMemo, useState } from "react";
+import { buildUpdatedRuleText, dateTimeValueForInput, dateTimeValueFromInput } from "./rule-value-edit.js";
+import { Button } from "#components/button/index";
+import { Input } from "#components/input/index";
+import { narrativeSegmentsAroundEdit, RuleNarrativeSegments, } from "#ldo-ui";
+const inputDescriptorByKind = {
+    number: {
+        type: "number",
+        step: "any",
+        inputMode: "decimal",
+        toInputValue: identity,
+        fromInputValue: identity,
+    },
+    date: {
+        type: "date",
+        toInputValue: identity,
+        fromInputValue: identity,
+    },
+    dateTime: {
+        type: "datetime-local",
+        step: "1",
+        helperText: "UTC timezone",
+        toInputValue: dateTimeValueForInput,
+        fromInputValue: dateTimeValueFromInput,
+    },
+};
+export function RuleValueControls(props) {
+    const { model, onStageChange } = props;
+    const idPrefix = useId();
+    const [values, setValues] = useState({});
+    const [isStaging, setIsStaging] = useState(false);
+    const buildResult = useMemo(() => buildUpdatedRuleText(model, values), [model, values]);
+    useEffect(() => {
+        setValues({});
+    }, [model.ast.raw]);
+    if (!isPresent(model.editableValues))
+        return null;
+    const hasFieldErrors = isPresent(Object.keys(buildResult.fieldErrors));
+    const canStage = buildResult.changed && !hasFieldErrors && !buildResult.error && !isStaging;
+    function handleChange(editableValue, value) {
+        setValues((current) => ({ ...current, [editableValue.id]: value }));
+    }
+    async function handleStage() {
+        if (!canStage)
+            return;
+        setIsStaging(true);
+        try {
+            await onStageChange(buildResult.ruleText);
+        }
+        finally {
+            setIsStaging(false);
+        }
+    }
+    return (_jsxs("div", { className: "mt-4 border-t border-muted-border pt-4", children: [_jsxs("div", { className: "mb-3 flex items-center justify-between gap-3", children: [_jsxs("div", { className: "flex min-w-0 items-center gap-2 text-default-foreground", children: [_jsx(SlidersHorizontal, { className: "size-4 text-muted-foreground" }), _jsx("h3", { className: "typography-small-medium", children: "Values" })] }), _jsxs("div", { className: "flex shrink-0 items-center gap-2", children: [_jsx(Button, { type: "button", variant: "secondary", size: "sm", icon: RotateCcw, onClick: () => setValues({}), disabled: !buildResult.changed || isStaging, children: "Reset" }), _jsx(Button, { type: "button", size: "sm", icon: Save, onClick: () => void handleStage(), disabled: !canStage, children: isStaging ? "Staging..." : "Stage Values" })] })] }), _jsx("div", { className: "flex flex-col divide-y divide-muted-border", children: model.editableValues.map(({ edit: editableValue, segments }) => {
+                    const value = values[editableValue.id] ?? editableValue.value;
+                    const inputId = `${idPrefix}-${editableValue.id}`;
+                    const inputDescriptor = inputDescriptorByKind[editableValue.kind];
+                    const inputValue = inputDescriptor.toInputValue(value);
+                    const contextSegments = narrativeSegmentsAroundEdit(segments, editableValue.id);
+                    return (_jsxs("div", { className: "grid gap-3 py-3 md:grid-cols-[minmax(0,1fr)_12rem] md:items-center", children: [_jsx("label", { htmlFor: inputId, className: "min-w-0", children: _jsx("span", { className: "block whitespace-normal break-words typography-small leading-6 text-default-foreground", children: _jsx(RuleNarrativeSegments, { variant: "edit-context", segments: contextSegments, activeEditId: editableValue.id }) }) }), _jsx(Input, { id: inputId, className: "w-full", type: inputDescriptor.type, step: inputDescriptor.step, inputMode: inputDescriptor.inputMode, value: inputValue, error: buildResult.fieldErrors[editableValue.id], helperText: inputDescriptor.helperText, onChange: (event) => {
+                                    handleChange(editableValue, inputDescriptor.fromInputValue(event.target.value));
+                                } })] }, editableValue.id));
+                }) }), buildResult.error && _jsx("p", { className: "mt-3 typography-caption text-error-foreground", children: buildResult.error })] }));
+}

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

@@ -0,0 +1,14 @@
+export type SupportedActionShapeRef = {
+    actionShape: string;
+};
+export type RuleActionabilityAnalysis = {
+    isAutomaticallyActionable: boolean;
+    isManualActioning: boolean;
+    hasTargetGraph: boolean;
+    hasSupportedActionShape: boolean;
+    actionShapeIris: string[];
+    supportedActionShapeIris: string[];
+    parseError: string | null;
+};
+export declare function analyzeRuleActionability(ruleText: string | null | undefined, supportedActionShapes: readonly SupportedActionShapeRef[], targetGraphIris?: readonly string[]): RuleActionabilityAnalysis;
+//# sourceMappingURL=rule-actionability.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule-actionability.d.ts","sourceRoot":"","sources":["../../../../src/routes/rules/components/rule-actionability.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,uBAAuB,GAAG;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9D,MAAM,MAAM,yBAAyB,GAAG;IACtC,yBAAyB,EAAE,OAAO,CAAC;IACnC,iBAAiB,EAAE,OAAO,CAAC;IAC3B,cAAc,EAAE,OAAO,CAAC;IACxB,uBAAuB,EAAE,OAAO,CAAC;IACjC,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,wBAAwB,EAAE,MAAM,EAAE,CAAC;IACnC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B,CAAC;AAEF,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACnC,qBAAqB,EAAE,SAAS,uBAAuB,EAAE,EACzD,eAAe,GAAE,SAAS,MAAM,EAAO,GACtC,yBAAyB,CA2B3B"}

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

@@ -0,0 +1,74 @@
+import { expandPrefix, wellKnownPredicates } from "@manta-eu/client/shared/rdf-namespaces";
+import { isIriTerm, isPropertyAtom, isTripleAtom } from "@manta-eu/datalog-parser";
+import { isPresent } from "@manta-eu/lib/present";
+import { uniq } from "ramda";
+import { parseDatalogRuleCached } from "#ldo-ui";
+export function analyzeRuleActionability(ruleText, supportedActionShapes, targetGraphIris = []) {
+    const hasTargetGraph = isPresent(targetGraphIris);
+    if (!ruleText) {
+        return emptyAnalysis(null, hasTargetGraph);
+    }
+    const { ast, error } = parseDatalogRuleCached(ruleText);
+    if (!ast) {
+        return emptyAnalysis(error, hasTargetGraph);
+    }
+    const supportedShapeSet = new Set(supportedActionShapes.map((shape) => normalizeIri(shape.actionShape)));
+    const actionShapeIris = uniq(ast.head.flatMap(actionShapeIrisFromHeadAtom));
+    const supportedActionShapeIris = actionShapeIris.filter((iri) => supportedShapeSet.has(iri));
+    const hasSupportedActionShape = isPresent(supportedActionShapeIris);
+    const isManualActioning = hasTargetGraph && !hasSupportedActionShape;
+    return {
+        isAutomaticallyActionable: !isManualActioning,
+        isManualActioning,
+        hasTargetGraph,
+        hasSupportedActionShape,
+        actionShapeIris,
+        supportedActionShapeIris,
+        parseError: null,
+    };
+}
+function emptyAnalysis(parseError, hasTargetGraph) {
+    const isManualActioning = hasTargetGraph;
+    return {
+        isAutomaticallyActionable: !isManualActioning,
+        isManualActioning,
+        hasTargetGraph,
+        hasSupportedActionShape: false,
+        actionShapeIris: [],
+        supportedActionShapeIris: [],
+        parseError,
+    };
+}
+function actionShapeIrisFromHeadAtom(atom) {
+    if (isPropertyAtom(atom)) {
+        if (!isActionShapePredicate(atom.predicate)) {
+            return [];
+        }
+        const objectIri = iriTermValue(atom.object);
+        return objectIri ? [objectIri] : [];
+    }
+    if (isTripleAtom(atom)) {
+        const predicateIri = iriTermValue(atom.predicate);
+        if (!predicateIri || !isActionShapePredicate(predicateIri)) {
+            return [];
+        }
+        const objectIri = iriTermValue(atom.object);
+        return objectIri ? [objectIri] : [];
+    }
+    return [];
+}
+function iriTermValue(term) {
+    if (!isIriTerm(term)) {
+        return null;
+    }
+    return normalizeIri(term.value);
+}
+function isActionShapePredicate(predicate) {
+    return normalizeIri(predicate) === wellKnownPredicates.actionShape;
+}
+function normalizeIri(value) {
+    const trimmed = value.trim();
+    const withoutAngles = trimmed.startsWith("<") && trimmed.endsWith(">") ? trimmed.slice(1, -1) : trimmed;
+    const normalizedPrefix = withoutAngles.startsWith("m:") ? `:${withoutAngles.slice(2)}` : withoutAngles;
+    return expandPrefix(normalizedPrefix);
+}