@jupytergis/base 0.5.0 → 0.6.1

package/lib/processing/processingCommands.js

@@ -0,0 +1,47 @@
+import { ProcessingMerge, ProcessingLogicType, } from '@jupytergis/schema';
+import { selectedLayerIsOfType, processSelectedLayer } from './index';
+export function replaceInSql(sql, keyToVal, layerName) {
+    const replaceTemplateString = (args) => args.template.replace(RegExp(`{${args.variableName}}`, 'g'), args.value);
+    let out = replaceTemplateString({
+        variableName: 'layerName',
+        template: sql,
+        value: layerName,
+    });
+    for (const [key, value] of Object.entries(keyToVal)) {
+        out = replaceTemplateString({
+            variableName: key,
+            template: out,
+            value: value,
+        });
+    }
+    return out;
+}
+export function addProcessingCommands(app, commands, tracker, trans, formSchemaRegistry) {
+    for (const processingElement of ProcessingMerge) {
+        if (processingElement.type === ProcessingLogicType.vector) {
+            commands.addCommand(processingElement.name, {
+                label: trans.__(processingElement.label),
+                isEnabled: () => selectedLayerIsOfType(['VectorLayer'], tracker),
+                execute: async () => {
+                    await processSelectedLayer(tracker, formSchemaRegistry, processingElement.description, {
+                        sqlQueryFn: (layerName, keyToVal) => replaceInSql(processingElement.operations.sql, keyToVal, layerName),
+                        gdalFunction: processingElement.operations.gdalFunction,
+                        options: (sqlQuery) => [
+                            '-f',
+                            'GeoJSON',
+                            '-dialect',
+                            'SQLITE',
+                            '-sql',
+                            sqlQuery,
+                            'output.geojson',
+                        ],
+                    }, app);
+                },
+            });
+        }
+        else {
+            console.error('Unsupported process type');
+            return;
+        }
+    }
+}

package/lib/processing/processingFormToParam.d.ts

@@ -0,0 +1,2 @@
+import { ProcessingType, IDict } from '@jupytergis/schema';
+export declare function processingFormToParam(formValues: IDict, processingType: ProcessingType): IDict<any> | undefined;

package/lib/processing/processingFormToParam.js

@@ -0,0 +1,15 @@
+import { processingList, ProcessingMerge, } from '@jupytergis/schema';
+export function processingFormToParam(formValues, processingType) {
+    if (!processingList.includes(processingType)) {
+        console.error(`Unsupported processing type: ${processingType}`);
+        return;
+    }
+    const processingElement = ProcessingMerge.find(e => e.description === processingType);
+    const params = processingElement.operationParams;
+    const out = {};
+    for (let i = 0; i < params.length; i++) {
+        const param = params[i];
+        out[param] = formValues[param];
+    }
+    return out;
+}

package/lib/shared/components/Badge.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+interface IBadgeProps extends React.HTMLAttributes<HTMLButtonElement> {
+    variant?: 'destructive' | 'outline' | 'secondary';
+    size?: 'sm' | 'lg' | 'icon';
+}
+declare function Badge({ variant, className, ...props }: IBadgeProps): React.JSX.Element;
+export default Badge;

package/lib/shared/components/Badge.js

@@ -0,0 +1,20 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import * as React from 'react';
+import { cn } from './utils';
+function Badge(_a) {
+    var { variant, className } = _a, props = __rest(_a, ["variant", "className"]);
+    return (
+    // @ts-expect-error lol
+    React.createElement("div", Object.assign({ "data-variant": variant, className: cn('jgis-badge', className) }, props)));
+}
+export default Badge;

package/lib/shared/components/Button.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+interface IButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean;
+    variant?: 'destructive' | 'outline' | 'secondary' | 'ghost' | 'link' | 'icon';
+    size?: 'sm' | 'lg' | 'icon' | 'icon-sm';
+}
+declare const Button: React.ForwardRefExoticComponent<IButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button };
+export type { IButtonProps as ButtonProps };

package/lib/shared/components/Button.js

@@ -0,0 +1,21 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { Slot } from '@radix-ui/react-slot';
+import * as React from 'react';
+import { cn } from './utils';
+const Button = React.forwardRef((_a, ref) => {
+    var { variant, className, size, asChild = false } = _a, props = __rest(_a, ["variant", "className", "size", "asChild"]);
+    const Comp = asChild ? Slot : 'button';
+    return (React.createElement(Comp, Object.assign({ "data-size": size, "data-variant": variant, className: cn('jgis-button', className), ref: ref }, props)));
+});
+Button.displayName = 'Button';
+export { Button };

package/lib/shared/components/Calendar.d.ts

@@ -0,0 +1,47 @@
+import * as React from 'react';
+import { type DayPickerProps } from 'react-day-picker';
+export type CalendarProps = DayPickerProps & {
+    /**
+     * In the year view, the number of years to display at once.
+     * @default 12
+     */
+    yearRange?: number;
+    /**
+     * Wether to show the year switcher in the caption.
+     * @default true
+     */
+    showYearSwitcher?: boolean;
+    monthsClassName?: string;
+    monthCaptionClassName?: string;
+    weekdaysClassName?: string;
+    weekdayClassName?: string;
+    monthClassName?: string;
+    captionClassName?: string;
+    captionLabelClassName?: string;
+    buttonNextClassName?: string;
+    buttonPreviousClassName?: string;
+    navClassName?: string;
+    monthGridClassName?: string;
+    weekClassName?: string;
+    dayClassName?: string;
+    dayButtonClassName?: string;
+    rangeStartClassName?: string;
+    rangeEndClassName?: string;
+    selectedClassName?: string;
+    todayClassName?: string;
+    outsideClassName?: string;
+    disabledClassName?: string;
+    rangeMiddleClassName?: string;
+    hiddenClassName?: string;
+};
+/**
+ * A custom calendar component built on top of react-day-picker.
+ * @param props The props for the calendar.
+ * @default yearRange 12
+ * @returns
+ */
+declare function Calendar({ className, showOutsideDays, showYearSwitcher, yearRange, numberOfMonths, components, ...props }: CalendarProps): React.JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+export { Calendar };

package/lib/shared/components/Calendar.js

@@ -0,0 +1,184 @@
+'use client';
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { differenceInCalendarDays } from 'date-fns';
+import { ChevronLeft, ChevronRight } from 'lucide-react';
+import * as React from 'react';
+import { DayPicker, labelNext, labelPrevious, useDayPicker, } from 'react-day-picker';
+import { Button } from './Button';
+import { cn } from './utils';
+/**
+ * A custom calendar component built on top of react-day-picker.
+ * @param props The props for the calendar.
+ * @default yearRange 12
+ * @returns
+ */
+function Calendar(_a) {
+    var { className, showOutsideDays = true, showYearSwitcher = true, yearRange = 12, numberOfMonths, components } = _a, props = __rest(_a, ["className", "showOutsideDays", "showYearSwitcher", "yearRange", "numberOfMonths", "components"]);
+    const [navView, setNavView] = React.useState('days');
+    const [displayYears, setDisplayYears] = React.useState(React.useMemo(() => {
+        const currentYear = new Date().getFullYear();
+        return {
+            from: currentYear - Math.floor(yearRange / 2 - 1),
+            to: currentYear + Math.ceil(yearRange / 2),
+        };
+    }, [yearRange]));
+    const { onNextClick, onPrevClick, startMonth, endMonth } = props;
+    const columnsDisplayed = navView === 'years' ? 1 : numberOfMonths;
+    const _monthsClassName = cn('jgis-calendar-months', props.monthsClassName);
+    const _monthCaptionClassName = cn('jgis-calendar-month-caption', props.monthCaptionClassName);
+    const _weekdaysClassName = cn('jgis-calendar-weekdays', props.weekdaysClassName);
+    const _weekdayClassName = cn('jgis-calendar-weekday', props.weekdayClassName);
+    const _monthClassName = cn('jgis-calendar-month', props.monthClassName);
+    const _captionClassName = cn('jgis-calendar-month-caption', props.captionClassName);
+    const _captionLabelClassName = cn('jgis-calendar-caption-label', props.captionLabelClassName);
+    const _buttonNextClassName = cn('jgis-calendar-button-next', props.buttonNextClassName);
+    const _buttonPreviousClassName = cn('jgis-calendar-button-previous', props.buttonPreviousClassName);
+    const _navClassName = cn('jgis-calendar-nav', props.navClassName);
+    const _monthGridClassName = cn('jgis-calendar-month-grid', props.monthGridClassName);
+    const _weekClassName = cn('jgis-calendar-week', props.weekClassName);
+    const _dayClassName = cn('jgis-calendar-day', props.dayClassName);
+    const _dayButtonClassName = cn('jgis-calendar-day-button', props.dayButtonClassName);
+    const _rangeStartClassName = cn('jgis-calendar-day-button range-start', props.rangeStartClassName);
+    const _rangeEndClassName = cn('jgis-calendar-day-button range-end', props.rangeEndClassName);
+    const _rangeMiddleClassName = cn('jgis-calendar-range-middle', props.rangeMiddleClassName);
+    const _selectedClassName = cn('jgis-calendar-day-selected', props.selectedClassName);
+    // const _todayClassName = cn('jgis-calendar-day-today', props.todayClassName);
+    const _outsideClassName = cn('jgis-calendar-day-outside', props.outsideClassName);
+    const _disabledClassName = cn('jgis-calendar-day-disabled', props.disabledClassName);
+    const _hiddenClassName = cn('jgis-calendar-hidden', props.hiddenClassName);
+    return (React.createElement(DayPicker, Object.assign({ showOutsideDays: showOutsideDays, className: cn('jgis-calendar-container', className), style: {
+            width: 248.8 * (columnsDisplayed !== null && columnsDisplayed !== void 0 ? columnsDisplayed : 1) + 'px',
+        }, classNames: {
+            months: _monthsClassName,
+            month_caption: _monthCaptionClassName,
+            weekdays: _weekdaysClassName,
+            weekday: _weekdayClassName,
+            month: _monthClassName,
+            caption: _captionClassName,
+            caption_label: _captionLabelClassName,
+            button_next: _buttonNextClassName,
+            button_previous: _buttonPreviousClassName,
+            nav: _navClassName,
+            month_grid: _monthGridClassName,
+            week: _weekClassName,
+            day: _dayClassName,
+            day_button: _dayButtonClassName,
+            range_start: _rangeStartClassName,
+            range_middle: _rangeMiddleClassName,
+            range_end: _rangeEndClassName,
+            selected: _selectedClassName,
+            // today: _todayClassName,
+            outside: _outsideClassName,
+            disabled: _disabledClassName,
+            hidden: _hiddenClassName,
+        }, components: Object.assign({ Chevron: ({ orientation }) => {
+                const Icon = orientation === 'left' ? ChevronLeft : ChevronRight;
+                return React.createElement(Icon, { className: "h-4 w-4" });
+            }, Nav: ({ className }) => (React.createElement(Nav, { className: className, displayYears: displayYears, navView: navView, setDisplayYears: setDisplayYears, startMonth: startMonth, endMonth: endMonth, onPrevClick: onPrevClick, onNextClick: onNextClick })), CaptionLabel: props => (React.createElement(CaptionLabel, Object.assign({ showYearSwitcher: showYearSwitcher, navView: navView, setNavView: setNavView, displayYears: displayYears }, props))), MonthGrid: (_a) => {
+                var { className, children } = _a, props = __rest(_a, ["className", "children"]);
+                return (React.createElement(MonthGrid, Object.assign({ children: children, className: className, displayYears: displayYears, startMonth: startMonth, endMonth: endMonth, navView: navView, setNavView: setNavView }, props)));
+            } }, components), numberOfMonths: columnsDisplayed, timeZone: "UTC" }, props)));
+}
+Calendar.displayName = 'Calendar';
+function Nav({ className, navView, startMonth, endMonth, displayYears, setDisplayYears, onPrevClick, onNextClick, }) {
+    const { nextMonth, previousMonth, goToMonth } = useDayPicker();
+    const isPreviousDisabled = (() => {
+        if (navView === 'years') {
+            return ((startMonth &&
+                differenceInCalendarDays(new Date(displayYears.from - 1, 0, 1), startMonth) < 0) ||
+                (endMonth &&
+                    differenceInCalendarDays(new Date(displayYears.from - 1, 0, 1), endMonth) > 0));
+        }
+        return !previousMonth;
+    })();
+    const isNextDisabled = (() => {
+        if (navView === 'years') {
+            return ((startMonth &&
+                differenceInCalendarDays(new Date(displayYears.to + 1, 0, 1), startMonth) < 0) ||
+                (endMonth &&
+                    differenceInCalendarDays(new Date(displayYears.to + 1, 0, 1), endMonth) > 0));
+        }
+        return !nextMonth;
+    })();
+    const handlePreviousClick = React.useCallback(() => {
+        if (!previousMonth) {
+            return;
+        }
+        if (navView === 'years') {
+            setDisplayYears(prev => ({
+                from: prev.from - (prev.to - prev.from + 1),
+                to: prev.to - (prev.to - prev.from + 1),
+            }));
+            onPrevClick === null || onPrevClick === void 0 ? void 0 : onPrevClick(new Date(displayYears.from - (displayYears.to - displayYears.from), 0, 1));
+            return;
+        }
+        goToMonth(previousMonth);
+        onPrevClick === null || onPrevClick === void 0 ? void 0 : onPrevClick(previousMonth);
+    }, [previousMonth, goToMonth]);
+    const handleNextClick = React.useCallback(() => {
+        if (!nextMonth) {
+            return;
+        }
+        if (navView === 'years') {
+            setDisplayYears(prev => ({
+                from: prev.from + (prev.to - prev.from + 1),
+                to: prev.to + (prev.to - prev.from + 1),
+            }));
+            onNextClick === null || onNextClick === void 0 ? void 0 : onNextClick(new Date(displayYears.from + (displayYears.to - displayYears.from), 0, 1));
+            return;
+        }
+        goToMonth(nextMonth);
+        onNextClick === null || onNextClick === void 0 ? void 0 : onNextClick(nextMonth);
+    }, [goToMonth, nextMonth]);
+    return (React.createElement("nav", { className: cn('jgis-calendar-nav', className) },
+        React.createElement(Button, { variant: "ghost", className: "jgis-calendar-button-previous", type: "button", tabIndex: isPreviousDisabled ? undefined : -1, disabled: isPreviousDisabled, "aria-label": navView === 'years'
+                ? `Go to the previous ${displayYears.to - displayYears.from + 1} years`
+                : labelPrevious(previousMonth), onClick: handlePreviousClick },
+            React.createElement(ChevronLeft, { className: "h-4 w-4" })),
+        React.createElement(Button, { variant: "ghost", className: "jgis-calendar-button-next", type: "button", tabIndex: isNextDisabled ? undefined : -1, disabled: isNextDisabled, "aria-label": navView === 'years'
+                ? `Go to the next ${displayYears.to - displayYears.from + 1} years`
+                : labelNext(nextMonth), onClick: handleNextClick },
+            React.createElement(ChevronRight, { className: "h-4 w-4" }))));
+}
+function CaptionLabel(_a) {
+    var { children, showYearSwitcher, navView, setNavView, displayYears } = _a, props = __rest(_a, ["children", "showYearSwitcher", "navView", "setNavView", "displayYears"]);
+    if (!showYearSwitcher) {
+        return React.createElement("span", Object.assign({}, props), children);
+    }
+    return (React.createElement(Button, { className: "jgis-calendar-caption-button", variant: "ghost", size: "sm", onClick: () => setNavView(prev => (prev === 'days' ? 'years' : 'days')) }, navView === 'days'
+        ? children
+        : displayYears.from + ' - ' + displayYears.to));
+}
+function MonthGrid(_a) {
+    var { className, children, displayYears, startMonth, endMonth, navView, setNavView } = _a, props = __rest(_a, ["className", "children", "displayYears", "startMonth", "endMonth", "navView", "setNavView"]);
+    if (navView === 'years') {
+        return (React.createElement(YearGrid, Object.assign({ displayYears: displayYears, startMonth: startMonth, endMonth: endMonth, setNavView: setNavView, navView: navView, className: className }, props)));
+    }
+    return (React.createElement("table", Object.assign({ className: className }, props), children));
+}
+function YearGrid(_a) {
+    var { className, displayYears, startMonth, endMonth, setNavView, navView } = _a, props = __rest(_a, ["className", "displayYears", "startMonth", "endMonth", "setNavView", "navView"]);
+    const { goToMonth, selected } = useDayPicker();
+    return (React.createElement("div", Object.assign({ className: cn('jgis-calendar-year-grid', className) }, props), Array.from({ length: displayYears.to - displayYears.from + 1 }, (_, i) => {
+        const isBefore = differenceInCalendarDays(new Date(displayYears.from + i, 11, 31), startMonth) < 0;
+        const isAfter = differenceInCalendarDays(new Date(displayYears.from + i, 0, 0), endMonth) > 0;
+        const isDisabled = isBefore || isAfter;
+        return (React.createElement(Button, { key: i, className: cn('jgis-calendar-year-button', displayYears.from + i === new Date().getFullYear() &&
+                'jgis-calendar-year-button-current', isDisabled && 'jgis-calendar-year-button-disabled'), variant: "ghost", onClick: () => {
+                var _a;
+                setNavView('days');
+                goToMonth(new Date(displayYears.from + i, (_a = selected === null || selected === void 0 ? void 0 : selected.getMonth()) !== null && _a !== void 0 ? _a : 0));
+            }, disabled: navView === 'years' ? isDisabled : undefined }, displayYears.from + i));
+    })));
+}
+export { Calendar };

package/lib/shared/components/Checkbox.d.ts

@@ -0,0 +1,4 @@
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import * as React from 'react';
+declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export default Checkbox;

package/lib/shared/components/Checkbox.js

@@ -0,0 +1,25 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import * as CheckboxPrimitive from '@radix-ui/react-checkbox';
+import { Check } from 'lucide-react';
+import * as React from 'react';
+const Checkbox = React.forwardRef((_a, ref) => {
+    var props = __rest(_a, []);
+    return (React.createElement(CheckboxPrimitive.Root, Object.assign({ ref: ref, className: 'jgis-checkbox' }, props),
+        React.createElement(CheckboxPrimitive.Indicator, { className: 'jgis-checkbox-indicator' },
+            React.createElement(Check, { style: {
+                    height: '1rem',
+                    width: '1rem',
+                } }))));
+});
+Checkbox.displayName = CheckboxPrimitive.Root.displayName;
+export default Checkbox;

package/lib/shared/components/DropdownMenu.d.ts

@@ -0,0 +1,27 @@
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as React from 'react';
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

package/lib/shared/components/DropdownMenu.js

@@ -0,0 +1,92 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import { Check, ChevronRight, Circle } from 'lucide-react';
+import * as React from 'react';
+const DropdownMenu = DropdownMenuPrimitive.Root;
+const DropdownMenuTrigger = DropdownMenuPrimitive.Trigger;
+const DropdownMenuGroup = DropdownMenuPrimitive.Group;
+const DropdownMenuPortal = DropdownMenuPrimitive.Portal;
+const DropdownMenuSub = DropdownMenuPrimitive.Sub;
+const DropdownMenuRadioGroup = DropdownMenuPrimitive.RadioGroup;
+const DropdownMenuSubTrigger = React.forwardRef((_a, ref) => {
+    var { inset, children } = _a, props = __rest(_a, ["inset", "children"]);
+    return (React.createElement(DropdownMenuPrimitive.SubTrigger, Object.assign({ ref: ref, className: 'jgis-dropdown-menu-sub-trigger', style: {
+            paddingLeft: inset ? '2rem' : '0.5rem',
+        } }, props),
+        children,
+        React.createElement(ChevronRight, { className: "jgis-dropdown-menu-icon" })));
+});
+DropdownMenuSubTrigger.displayName =
+    DropdownMenuPrimitive.SubTrigger.displayName;
+const DropdownMenuSubContent = React.forwardRef((_a, ref) => {
+    var props = __rest(_a, []);
+    return (React.createElement(DropdownMenuPrimitive.SubContent, Object.assign({ ref: ref, className: 'jgis-dropdown-menu-sub-content' }, props)));
+});
+DropdownMenuSubContent.displayName =
+    DropdownMenuPrimitive.SubContent.displayName;
+const DropdownMenuContent = React.forwardRef((_a, ref) => {
+    var { sideOffset = 4 } = _a, props = __rest(_a, ["sideOffset"]);
+    return (React.createElement(DropdownMenuPrimitive.Portal, { container: document.querySelector('#main') },
+        React.createElement(DropdownMenuPrimitive.Content, Object.assign({ ref: ref, sideOffset: sideOffset, className: 'jgis-dropdown-menu-content' }, props))));
+});
+DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName;
+const DropdownMenuItem = React.forwardRef((_a, ref) => {
+    var { inset } = _a, props = __rest(_a, ["inset"]);
+    return (React.createElement(DropdownMenuPrimitive.Item, Object.assign({ ref: ref, className: 'jgis-dropdown-menu-item', style: {
+            paddingLeft: inset ? '2rem' : '0.5rem',
+        } }, props)));
+});
+DropdownMenuItem.displayName = DropdownMenuPrimitive.Item.displayName;
+const DropdownMenuCheckboxItem = React.forwardRef((_a, ref) => {
+    var { children, checked } = _a, props = __rest(_a, ["children", "checked"]);
+    return (React.createElement(DropdownMenuPrimitive.CheckboxItem, Object.assign({ ref: ref, className: 'jgis-dropdown-menu-checkbox-item', checked: checked }, props),
+        React.createElement("span", { className: 'jgis-dropdown-menu-checkbox-item-span' },
+            React.createElement(DropdownMenuPrimitive.ItemIndicator, null,
+                React.createElement(Check, { style: {
+                        height: '1rem',
+                        width: '1rem',
+                    } }))),
+        children));
+});
+DropdownMenuCheckboxItem.displayName =
+    DropdownMenuPrimitive.CheckboxItem.displayName;
+const DropdownMenuRadioItem = React.forwardRef((_a, ref) => {
+    var { children } = _a, props = __rest(_a, ["children"]);
+    return (React.createElement(DropdownMenuPrimitive.RadioItem, Object.assign({ ref: ref, className: 'jgis-dropdown-menu-radio-item' }, props),
+        React.createElement("span", { className: 'jgis-dropdown-menu-radio-item-span' },
+            React.createElement(DropdownMenuPrimitive.ItemIndicator, null,
+                React.createElement(Circle, { color: "currentColor", style: {
+                        height: '0.5rem',
+                        width: '0.5rem',
+                    } }))),
+        children));
+});
+DropdownMenuRadioItem.displayName = DropdownMenuPrimitive.RadioItem.displayName;
+const DropdownMenuLabel = React.forwardRef((_a, ref) => {
+    var { inset } = _a, props = __rest(_a, ["inset"]);
+    return (React.createElement(DropdownMenuPrimitive.Label, Object.assign({ ref: ref, className: 'jgis-dropdown-menu-label', style: {
+            paddingLeft: inset ? '2rem' : '0.5rem',
+        } }, props)));
+});
+DropdownMenuLabel.displayName = DropdownMenuPrimitive.Label.displayName;
+const DropdownMenuSeparator = React.forwardRef((_a, ref) => {
+    var props = __rest(_a, []);
+    return (React.createElement(DropdownMenuPrimitive.Separator, Object.assign({ ref: ref, className: 'jgis-dropdown-menu-separator' }, props)));
+});
+DropdownMenuSeparator.displayName = DropdownMenuPrimitive.Separator.displayName;
+const DropdownMenuShortcut = (_a) => {
+    var props = __rest(_a, []);
+    return React.createElement("span", Object.assign({ className: 'jgis-dropdown-menu-shortcut' }, props));
+};
+DropdownMenuShortcut.displayName = 'DropdownMenuShortcut';
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

package/lib/shared/components/Pagination.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import { ButtonProps } from './Button';
+declare const Pagination: React.FC<React.ComponentProps<'nav'>>;
+declare const PaginationContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const PaginationItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<ButtonProps, 'size'> & React.ComponentProps<'button'>;
+declare const PaginationLink: {
+    ({ isActive, size, ...props }: PaginationLinkProps): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationPrevious: {
+    ({ ...props }: React.ComponentProps<typeof PaginationLink>): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationNext: {
+    ({ ...props }: React.ComponentProps<typeof PaginationLink>): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationEllipsis: {
+    ({ ...props }: React.ComponentProps<"span">): React.JSX.Element;
+    displayName: string;
+};
+export { Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, };

package/lib/shared/components/Pagination.js

@@ -0,0 +1,68 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { ChevronLeft, ChevronRight, MoreHorizontal } from 'lucide-react';
+import * as React from 'react';
+import { Button } from './Button';
+const Pagination = (_a) => {
+    var props = __rest(_a, []);
+    return (React.createElement("nav", Object.assign({ role: "navigation", "aria-label": "pagination", className: 'jgis-pagination' }, props)));
+};
+Pagination.displayName = 'Pagination';
+const PaginationContent = React.forwardRef((_a, ref) => {
+    var props = __rest(_a, []);
+    return (React.createElement("ul", Object.assign({ ref: ref, className: 'jgis-pagination-content' }, props)));
+});
+PaginationContent.displayName = 'PaginationContent';
+const PaginationItem = React.forwardRef((_a, ref) => {
+    var props = __rest(_a, []);
+    return React.createElement("li", Object.assign({ ref: ref, className: "" }, props));
+});
+PaginationItem.displayName = 'PaginationItem';
+const PaginationLink = (_a) => {
+    var { isActive, size = 'icon' } = _a, props = __rest(_a, ["isActive", "size"]);
+    return (React.createElement(Button, Object.assign({ "aria-current": isActive ? 'page' : undefined, "data-variant": isActive ? 'outline' : 'ghost', "data-size": size, className: 'jgis-pagination-link' }, props)));
+};
+PaginationLink.displayName = 'PaginationLink';
+// size is 'default' from both next and previous
+const PaginationPrevious = (_a) => {
+    var props = __rest(_a, []);
+    return (React.createElement(PaginationLink, Object.assign({ "aria-label": "Go to previous page", className: 'jgis-pagination-previous' }, props),
+        React.createElement(ChevronLeft, { style: {
+                height: '1rem',
+                width: '1rem',
+                flexShrink: 0,
+            } }),
+        React.createElement("span", null, "Prev")));
+};
+PaginationPrevious.displayName = 'PaginationPrevious';
+const PaginationNext = (_a) => {
+    var props = __rest(_a, []);
+    return (React.createElement(PaginationLink, Object.assign({ "aria-label": "Go to next page", className: 'jgis-pagination-next' }, props),
+        React.createElement("span", null, "Next"),
+        React.createElement(ChevronRight, { style: {
+                height: '1rem',
+                width: '1rem',
+                flexShrink: 0,
+            } })));
+};
+PaginationNext.displayName = 'PaginationNext';
+const PaginationEllipsis = (_a) => {
+    var props = __rest(_a, []);
+    return (React.createElement("span", Object.assign({ "aria-hidden": true, className: 'jgis-pagination-ellipsis' }, props),
+        React.createElement(MoreHorizontal, { style: {
+                height: '1rem',
+                width: '1rem',
+            } }),
+        React.createElement("span", { className: "sr-only" }, "More pages")));
+};
+PaginationEllipsis.displayName = 'PaginationEllipsis';
+export { Pagination, PaginationContent, PaginationEllipsis, PaginationItem, PaginationLink, PaginationNext, PaginationPrevious, };

package/lib/shared/components/Popover.d.ts

@@ -0,0 +1,7 @@
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as React from 'react';
+declare const Popover: React.FC<React.ComponentProps<typeof PopoverPrimitive.Root>>;
+declare const PopoverTrigger: React.FC<React.ComponentProps<typeof PopoverPrimitive.Trigger>>;
+declare const PopoverContent: React.FC<React.ComponentProps<typeof PopoverPrimitive.Content>>;
+declare const PopoverAnchor: React.FC<React.ComponentProps<typeof PopoverPrimitive.Anchor>>;
+export { Popover, PopoverAnchor, PopoverContent, PopoverTrigger };