@manta-eu/react 0.1.0 → 0.1.2

package/dist/routes/memories/hooks/useMemoryColumns.js

@@ -0,0 +1,188 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { isTrustedUntilExpiringSoon } from "@manta-eu/client/shared/memory-preload-gate";
+import { formatEntityName } from "@manta-eu/client/shared/rdf-namespaces";
+import { isPresent } from "@manta-eu/lib/present";
+import { addDays, format, formatDistanceToNow, isBefore } from "date-fns";
+import { ChevronDown, Clock } from "lucide-react";
+import { useMemo } from "react";
+import { AutoCapturedBadge, DuplicateBadge, KindBadge, MemoryAbout, MemoryEvidence, OutOfWindowBadge, PreloadedBadge, SchemaBadge, } from "../components/badges.js";
+import { ImportanceIcon } from "../components/ImportanceSlider.js";
+import { MemoryActions } from "../components/MemoryActions.js";
+import { compareMemoryHorizons, formatHorizonDate, formatHorizonTooltip, memoryHorizon, memoryWindowState, shouldShowValidFrom, } from "../expiry-utils.js";
+import { Tooltip, TooltipContent, TooltipTrigger } from "#components/tooltip/index";
+export const memoryColumnIds = {
+    label: "label",
+    description: "description",
+    kind: "kind",
+    teams: "teams",
+    used: "used",
+    actions: "actions",
+};
+export const memoryColumnLabels = {
+    [memoryColumnIds.label]: "Label",
+    [memoryColumnIds.description]: "Description",
+    [memoryColumnIds.kind]: "Type",
+    [memoryColumnIds.teams]: "Teams",
+    [memoryColumnIds.used]: "Used",
+};
+export const defaultColumnOrder = [
+    memoryColumnIds.label,
+    memoryColumnIds.description,
+    memoryColumnIds.kind,
+    memoryColumnIds.teams,
+    "importance",
+    "memoryValidUntil",
+    "createdBy",
+    "extractedAt",
+    memoryColumnIds.used,
+    memoryColumnIds.actions,
+];
+function getTeamName(path) {
+    return path.split("/").filter(Boolean).pop() ?? path;
+}
+function formatCreatedBy(createdBy, currentUserId) {
+    if (!createdBy)
+        return "Manta";
+    if (createdBy === currentUserId)
+        return "You";
+    return "Another user";
+}
+function MaybeTooltip(props) {
+    const { tooltip, children } = props;
+    if (tooltip == null)
+        return children;
+    return (_jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: children }), _jsx(TooltipContent, { children: tooltip })] }));
+}
+export function useMemoryColumns(args) {
+    const { isOperator, userId, schemas, onEdit, onDelete, onMove, onRestore, onReconfirm, duplicates } = args;
+    return useMemo(() => {
+        const schemaByIri = new Map(schemas?.map((s) => [s.iri, s]) ?? []);
+        return [
+            {
+                id: memoryColumnIds.label,
+                accessorKey: "label",
+                header: "Label",
+                enableSorting: false,
+                meta: { className: "max-w-72" },
+                cell: ({ row }) => {
+                    const windowState = memoryWindowState(row.original.memoryValidFrom, row.original.memoryValidUntil);
+                    return (_jsxs("span", { className: "flex min-w-48 flex-wrap items-start gap-1.5 whitespace-normal typography-caption-medium text-default-foreground", children: [_jsx("span", { className: "line-clamp-2 min-w-24 max-w-full break-words", children: row.original.label }), row.original.supersededBy != null && (_jsx("span", { className: "inline-flex items-center rounded-full px-2 py-0.5 typography-tiny bg-faint text-muted-foreground border border-muted-border", children: "Archived" })), windowState === "active" ? (_jsx(PreloadedBadge, { memory: row.original })) : (_jsx(OutOfWindowBadge, { state: windowState })), row.original.confidence != null && row.original.confidence < 1 && (_jsx(AutoCapturedBadge, { confidence: row.original.confidence })), duplicates?.get(row.original.iri) != null && (_jsx(DuplicateBadge, { matches: (duplicates.get(row.original.iri) ?? []).map((c) => ({ label: c.label, reason: c.reason })) }))] }));
+                },
+            },
+            {
+                id: memoryColumnIds.description,
+                accessorKey: "description",
+                header: "Description",
+                enableSorting: false,
+                meta: { className: "max-w-96" },
+                cell: ({ row }) => (_jsxs("span", { className: "flex w-full min-w-56 flex-col", children: [_jsx("span", { className: "text-muted-foreground line-clamp-5 whitespace-normal break-words", children: row.original.description }), _jsx(MemoryAbout, { aboutEntityIris: row.original.aboutEntityIris }), _jsx(MemoryEvidence, { evidence: row.original.memoryEvidence })] })),
+            },
+            {
+                id: memoryColumnIds.kind,
+                accessorKey: "kind",
+                header: "Type",
+                enableSorting: true,
+                meta: { className: "max-w-52" },
+                filterFn: (row, _columnId, filterValue) => row.original.memorySubclass === filterValue || row.original.kind === filterValue,
+                cell: ({ row }) => {
+                    const props = row.original.customProperties;
+                    const filledEntries = props ? Object.entries(props).filter(([, v]) => isPresent(v)) : [];
+                    const schema = row.original.memorySubclass ? schemaByIri.get(row.original.memorySubclass) : undefined;
+                    const schemaLabel = row.original.memorySubclass
+                        ? (schema?.label ?? formatEntityName(row.original.memorySubclass))
+                        : null;
+                    const badges = (_jsxs(_Fragment, { children: [_jsx(KindBadge, { kind: row.original.kind }), _jsx(SchemaBadge, { label: schemaLabel })] }));
+                    if (!isPresent(filledEntries)) {
+                        return _jsx("div", { className: "flex min-w-36 flex-wrap items-center gap-1.5", children: badges });
+                    }
+                    return (_jsx("div", { className: "flex min-w-36 flex-wrap items-center gap-1.5", children: _jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: _jsxs("div", { className: "inline-flex w-fit flex-wrap items-center gap-1.5", children: [badges, _jsxs("span", { className: "inline-flex items-center gap-0.5 rounded-full px-2 py-0.5 typography-tiny bg-faint border border-muted-border text-muted-foreground", children: [filledEntries.length, _jsx(ChevronDown, { className: "size-3" })] })] }) }), _jsx(TooltipContent, { className: "typography-small text-left max-w-sm", children: _jsx("div", { className: "flex flex-col gap-1", children: filledEntries.map(([path, value]) => {
+                                            const propDef = schema?.properties.find((p) => p.path === path);
+                                            const label = propDef?.label ?? formatEntityName(path);
+                                            return (_jsxs("div", { className: "flex items-center gap-1.5", children: [_jsxs("span", { className: "text-muted-foreground shrink-0 whitespace-nowrap", children: [label, ":"] }), _jsx("span", { className: "min-w-0 truncate", children: value })] }, path));
+                                        }) }) })] }) }));
+                },
+            },
+            {
+                id: memoryColumnIds.teams,
+                accessorKey: "teams",
+                header: "Teams",
+                enableSorting: false,
+                cell: ({ row }) => {
+                    const teams = row.original.teams;
+                    if (!isPresent(teams))
+                        return _jsx("span", { className: "typography-small text-muted-foreground", children: "-" });
+                    if (teams.length === 1) {
+                        return _jsx("span", { className: "typography-small text-muted-foreground", children: getTeamName(teams[0] ?? "") });
+                    }
+                    return (_jsxs(Tooltip, { children: [_jsx(TooltipTrigger, { asChild: true, children: _jsxs("span", { className: "typography-small text-muted-foreground cursor-default", children: [teams.length, " teams"] }) }), _jsx(TooltipContent, { children: _jsx("div", { className: "flex flex-col gap-1", children: teams.map((path) => (_jsx("span", { children: getTeamName(path) }, path))) }) })] }));
+                },
+            },
+            {
+                id: "importance",
+                accessorKey: "importance",
+                header: "Importance",
+                enableSorting: true,
+                cell: ({ row }) => _jsx(ImportanceIcon, { value: row.original.importance }),
+            },
+            {
+                id: "memoryValidUntil",
+                accessorKey: "memoryValidUntil",
+                header: "Expires",
+                enableSorting: true,
+                sortingFn: (a, b) => compareMemoryHorizons(memoryHorizon(a.original.memoryValidUntil, a.original.memoryTrustedUntil), memoryHorizon(b.original.memoryValidUntil, b.original.memoryTrustedUntil)),
+                cell: ({ row }) => {
+                    const horizon = memoryHorizon(row.original.memoryValidUntil, row.original.memoryTrustedUntil);
+                    const expiresSoon = horizon.kind === "expiry"
+                        ? isBefore(new Date(horizon.at), addDays(new Date(), 7))
+                        : horizon.kind === "trust" && isTrustedUntilExpiringSoon(horizon.at, new Date());
+                    return (_jsx(MaybeTooltip, { tooltip: horizon.kind === "none" ? null : formatHorizonTooltip(horizon), children: _jsxs("span", { className: `inline-flex items-center gap-1 typography-small ${expiresSoon ? "text-warning-foreground" : "text-muted-foreground"}`, children: [_jsx(Clock, { className: "size-3 shrink-0" }), formatHorizonDate(horizon)] }) }));
+                },
+            },
+            {
+                id: "createdBy",
+                accessorKey: "createdBy",
+                header: "Owner",
+                enableSorting: false,
+                cell: ({ row }) => (_jsx("span", { className: "typography-small text-muted-foreground", children: formatCreatedBy(row.original.createdBy, userId) })),
+            },
+            {
+                id: memoryColumnIds.used,
+                accessorFn: (memory) => memory.memoryUseCount + memory.memoryCiteCount,
+                header: "Used",
+                enableSorting: true,
+                cell: ({ row }) => {
+                    const preloaded = row.original.memoryUseCount;
+                    const cited = row.original.memoryCiteCount;
+                    const count = preloaded + cited;
+                    const lastUsedAt = row.original.memoryLastUsedAt;
+                    if (!count) {
+                        return _jsx("span", { className: "typography-small text-muted-foreground whitespace-nowrap", children: "Never" });
+                    }
+                    const lastUsedLine = lastUsedAt
+                        ? `Last used ${formatDistanceToNow(new Date(lastUsedAt), { addSuffix: true })}`
+                        : null;
+                    return (_jsx(MaybeTooltip, { tooltip: _jsxs(_Fragment, { children: [_jsxs("div", { children: [preloaded, "\u00D7 pre-loaded, ", cited, "\u00D7 cited"] }), lastUsedLine ? _jsx("div", { children: lastUsedLine }) : null] }), children: _jsxs("span", { className: "typography-small whitespace-nowrap", children: [count, "\u00D7"] }) }));
+                },
+            },
+            {
+                id: "extractedAt",
+                accessorKey: "updatedAt",
+                header: "Updated",
+                enableSorting: true,
+                cell: ({ row }) => {
+                    const validFrom = row.original.memoryValidFrom;
+                    const tooltip = validFrom && shouldShowValidFrom(row.original.updatedAt, validFrom)
+                        ? `True since ${format(new Date(validFrom), "MMM d, yyyy")} — older than this record`
+                        : null;
+                    return (_jsx(MaybeTooltip, { tooltip: tooltip, children: _jsx("span", { className: "typography-small text-muted-foreground whitespace-nowrap", children: formatDistanceToNow(new Date(row.original.updatedAt), { addSuffix: true }) }) }));
+                },
+            },
+            {
+                id: memoryColumnIds.actions,
+                enableHiding: false,
+                enableSorting: false,
+                cell: ({ row }) => (_jsx(MemoryActions, { memory: row.original, isOperator: isOperator, onEdit: onEdit, onDelete: onDelete, onMove: onMove, onRestore: onRestore, onReconfirm: onReconfirm })),
+            },
+        ];
+    }, [isOperator, userId, schemas, onEdit, onDelete, onMove, onRestore, onReconfirm, duplicates]);
+}

package/dist/routes/memories/hooks/useMemoryTable.d.ts

@@ -0,0 +1,33 @@
+import type { GQLMemory } from "@manta-eu/client";
+import type { ColumnDef, SortingState, Table } from "@tanstack/react-table";
+import type { KindFilter, SchemaFilter } from "../components/MemoriesFilters.js";
+export type { KindFilter, SchemaFilter };
+export type ImportanceFilter = 0 | 1 | 2 | 3 | 4 | 5;
+export type StatusFilterKey = "autoCaptured" | "hideStale" | "promotion" | "deadWeight" | "unused" | "needsReview";
+export type MemoryFilterCriteria = {
+    search: string;
+    importance: ImportanceFilter;
+    autoCaptured: boolean;
+    hideStale: boolean;
+    promotion: boolean;
+    deadWeight: boolean;
+    unused: boolean;
+    needsReview: boolean;
+    schema: SchemaFilter;
+};
+export declare function filterMemories(data: GQLMemory[], criteria: MemoryFilterCriteria, now?: Date): GQLMemory[];
+export type UseMemoryTableResult = {
+    table: Table<GQLMemory>;
+    kindFilter: KindFilter;
+    onKindFilterChange: (kind: KindFilter) => void;
+    schemaFilter: SchemaFilter;
+    onSchemaFilterChange: (iri: SchemaFilter) => void;
+    searchQuery: string;
+    onSearchQueryChange: (query: string) => void;
+    importanceFilter: ImportanceFilter;
+    onImportanceFilterChange: (importance: ImportanceFilter) => void;
+    statusFilters: Record<StatusFilterKey, boolean>;
+    onStatusFilterChange: (key: StatusFilterKey, value: boolean) => void;
+};
+export declare function useMemoryTable(tableKey: string, data: GQLMemory[], columns: ColumnDef<GQLMemory>[], initialSorting?: SortingState, initialColumnVisibility?: Record<string, boolean>): UseMemoryTableResult;
+//# sourceMappingURL=useMemoryTable.d.ts.map

package/dist/routes/memories/hooks/useMemoryTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMemoryTable.d.ts","sourceRoot":"","sources":["../../../../src/routes/memories/hooks/useMemoryTable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAOlD,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAmB,MAAM,uBAAuB,CAAC;AAM7F,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAK9E,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC;AAEzC,MAAM,MAAM,gBAAgB,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAErD,MAAM,MAAM,eAAe,GAAG,cAAc,GAAG,WAAW,GAAG,WAAW,GAAG,YAAY,GAAG,QAAQ,GAAG,aAAa,CAAC;AA0BnH,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,gBAAgB,CAAC;IAC7B,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,MAAM,EAAE,YAAY,CAAC;CACtB,CAAC;AAEF,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,QAAQ,EAAE,oBAAoB,EAAE,GAAG,GAAE,IAAiB,GAAG,SAAS,EAAE,CAgCrH;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IACxB,UAAU,EAAE,UAAU,CAAC;IACvB,kBAAkB,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IAC/C,YAAY,EAAE,YAAY,CAAC;IAC3B,oBAAoB,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,IAAI,CAAC;IAClD,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7C,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,wBAAwB,EAAE,CAAC,UAAU,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACjE,aAAa,EAAE,MAAM,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;IAChD,oBAAoB,EAAE,CAAC,GAAG,EAAE,eAAe,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACtE,CAAC;AAEF,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,SAAS,EAAE,EACjB,OAAO,EAAE,SAAS,CAAC,SAAS,CAAC,EAAE,EAC/B,cAAc,GAAE,YAAiB,EACjC,uBAAuB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChD,oBAAoB,CAiGtB"}

package/dist/routes/memories/hooks/useMemoryTable.js

@@ -0,0 +1,121 @@
+import { isMemoryPreloaded, isNeverUsed, needsTrustReview, parseMemoryDate, } from "@manta-eu/client/shared/memory-preload-gate";
+import { useReactTable } from "@tanstack/react-table";
+import { differenceInCalendarDays } from "date-fns";
+import { useCallback, useMemo, useState } from "react";
+import { match } from "ts-pattern";
+import { useDebounceValue, useLocalStorage } from "usehooks-ts";
+import { isTrustExpired } from "../expiry-utils.js";
+import { memoryColumnIds } from "./useMemoryColumns.js";
+import { createTableConfig, useTableState } from "#components/table/index";
+const defaultStatusFilters = {
+    autoCaptured: false,
+    hideStale: false,
+    promotion: false,
+    deadWeight: false,
+    unused: false,
+    needsReview: false,
+};
+const noColumnVisibility = {};
+const isAutoCaptured = (memory) => memory.confidence != null && memory.confidence < 1;
+const deadWeightUntouchedDays = 90;
+const isDeadWeight = (memory, now) => {
+    const lastTouched = parseMemoryDate(memory.memoryLastUsedAt) ?? parseMemoryDate(memory.extractedAt);
+    return (isMemoryPreloaded(memory, now) &&
+        lastTouched != null &&
+        differenceInCalendarDays(now, lastTouched) >= deadWeightUntouchedDays);
+};
+export function filterMemories(data, criteria, now = new Date()) {
+    let result = data;
+    if (criteria.search.trim()) {
+        const q = criteria.search.toLowerCase();
+        result = result.filter((m) => m.label.toLowerCase().includes(q) || (m.description ?? "").toLowerCase().includes(q));
+    }
+    if (criteria.importance !== 0) {
+        result = result.filter((m) => m.importance === criteria.importance);
+    }
+    if (criteria.autoCaptured) {
+        result = result.filter(isAutoCaptured);
+    }
+    if (criteria.hideStale) {
+        result = result.filter((m) => !isTrustExpired(m.memoryTrustedUntil, now));
+    }
+    // Promoting a stale memory would push an unconfirmed fact onto everyone in the company.
+    if (criteria.promotion) {
+        result = result.filter((m) => isAutoCaptured(m) && !isTrustExpired(m.memoryTrustedUntil, now));
+    }
+    if (criteria.deadWeight) {
+        result = result.filter((m) => isDeadWeight(m, now));
+    }
+    if (criteria.unused) {
+        result = result.filter((m) => isNeverUsed(m, now));
+    }
+    if (criteria.needsReview) {
+        result = result.filter((m) => needsTrustReview(m, now));
+    }
+    return match(criteria.schema)
+        .with("ALL", () => result)
+        .with("NONE", () => result.filter((m) => m.memorySubclass == null))
+        .otherwise((iri) => result.filter((m) => m.memorySubclass === iri));
+}
+export function useMemoryTable(tableKey, data, columns, initialSorting = [], initialColumnVisibility) {
+    const [searchQuery, setSearchQuery] = useState("");
+    const [debouncedSearch] = useDebounceValue(searchQuery, 200);
+    const [importanceFilter, setImportanceFilter] = useState(0);
+    const [statusFilters, setStatusFilters] = useState(defaultStatusFilters);
+    const [schemaFilter, setSchemaFilter] = useState("ALL");
+    const onStatusFilterChange = useCallback((key, value) => {
+        setStatusFilters((prev) => ({ ...prev, [key]: value }));
+    }, []);
+    const filteredData = useMemo(() => filterMemories(data, {
+        search: debouncedSearch,
+        importance: importanceFilter,
+        autoCaptured: statusFilters.autoCaptured,
+        hideStale: statusFilters.hideStale,
+        promotion: statusFilters.promotion,
+        deadWeight: statusFilters.deadWeight,
+        unused: statusFilters.unused,
+        needsReview: statusFilters.needsReview,
+        schema: schemaFilter,
+    }), [data, debouncedSearch, importanceFilter, statusFilters, schemaFilter]);
+    const { sorting, setSorting, columnFilters, setColumnFilters, columnOrder, setColumnOrder, rowSelection, setRowSelection, pagination, setPagination, } = useTableState(tableKey, initialSorting, { useLocalState: true, defaultPageSize: 12 });
+    // Keyed distinctly from useTableState so they don't collide in localStorage.
+    const [storedVisibility, setColumnVisibility] = useLocalStorage(`${tableKey}-visibility`, initialColumnVisibility ?? noColumnVisibility);
+    const columnVisibility = useMemo(() => ({ ...initialColumnVisibility, ...storedVisibility }), [initialColumnVisibility, storedVisibility]);
+    const table = useReactTable(createTableConfig({
+        data: filteredData,
+        columns,
+        columnPinning: { left: [memoryColumnIds.label], right: [memoryColumnIds.actions] },
+        sorting,
+        setSorting,
+        columnFilters,
+        setColumnFilters,
+        columnVisibility,
+        setColumnVisibility,
+        columnOrder,
+        setColumnOrder,
+        rowSelection,
+        setRowSelection,
+        pagination,
+        setPagination,
+    }));
+    const kindFilter = columnFilters.find((f) => f.id === memoryColumnIds.kind)?.value ?? "ALL";
+    const handleKindFilterChange = useCallback((kind) => {
+        setColumnFilters((prev) => [
+            ...prev.filter((f) => f.id !== memoryColumnIds.kind),
+            ...(kind !== "ALL" ? [{ id: memoryColumnIds.kind, value: kind }] : []),
+        ]);
+    }, [setColumnFilters]);
+    return {
+        table,
+        kindFilter,
+        onKindFilterChange: handleKindFilterChange,
+        schemaFilter,
+        onSchemaFilterChange: setSchemaFilter,
+        searchQuery,
+        onSearchQueryChange: setSearchQuery,
+        importanceFilter,
+        onImportanceFilterChange: setImportanceFilter,
+        statusFilters,
+        onStatusFilterChange,
+    };
+}

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

@@ -0,0 +1,11 @@
+import { deriveLabel } from "./memory-mutation-input.js";
+export { deriveLabel };
+export { KindBadge, ScopeBadge, preloadBadgeContent, type KindBadgeProps, type PreloadBadgeContent, type PreloadBadgeTone, type ScopeBadgeProps, } from "./components/badges.js";
+export { formatHorizonDate, formatHorizonRelative, memoryHorizon, type MemoryHorizon } from "./expiry-utils.js";
+export { filterMemories, type ImportanceFilter, type MemoryFilterCriteria, type SchemaFilter, } from "./hooks/useMemoryTable.js";
+export { GroupMemoriesEmptyState, MemoriesEmptyState, type GroupMemoriesEmptyStateProps, type MemoriesEmptyStateProps, } from "./components/EmptyStates.js";
+export { LoadingSkeleton } from "./components/LoadingSkeleton.js";
+export { MemoryFormDialog, type MemoryFormDialogProps } from "./components/MemoryFormDialog.js";
+export type { MemoryFormState } from "./components/MemoryFields.js";
+export declare function MemoriesRoute(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/routes/memories/index.tsx"],"names":[],"mappings":"AAuCA,OAAO,EAAkD,WAAW,EAAE,MAAM,yBAAyB,CAAC;AA8FtG,OAAO,EAAE,WAAW,EAAE,CAAC;AACvB,OAAO,EACL,SAAS,EACT,UAAU,EACV,mBAAmB,EACnB,KAAK,cAAc,EACnB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,eAAe,GACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC7G,OAAO,EACL,cAAc,EACd,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,YAAY,GAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,uBAAuB,EACvB,kBAAkB,EAClB,KAAK,4BAA4B,EACjC,KAAK,uBAAuB,GAC7B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAC/D,OAAO,EAAE,gBAAgB,EAAE,KAAK,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAC7F,YAAY,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAiCjE,wBAAgB,aAAa,4CAylB5B"}