@koine/react 2.0.0-beta.77 → 2.0.0-beta.78

package/calendar.esm.js

@@ -0,0 +1,561 @@
+import { jsx, jsxs, Fragment as Fragment$1 } from 'react/jsx-runtime';
+import { useState, Fragment, useEffect, useMemo, useReducer, useCallback } from 'react';
+import { addDays } from 'date-fns/addDays';
+import { addMonths } from 'date-fns/addMonths';
+import { addWeeks } from 'date-fns/addWeeks';
+import { endOfMonth } from 'date-fns/endOfMonth';
+import { endOfWeek } from 'date-fns/endOfWeek';
+import { isWithinInterval } from 'date-fns/isWithinInterval';
+import { startOfWeek } from 'date-fns/startOfWeek';
+import { subMonths } from 'date-fns/subMonths';
+import { subWeeks } from 'date-fns/subWeeks';
+import { format } from 'date-fns/format';
+import { eachWeekOfInterval } from 'date-fns/eachWeekOfInterval';
+import { useSwipeable } from 'react-swipeable';
+import { differenceInDays } from 'date-fns/differenceInDays';
+import { subDays } from 'date-fns/subDays';
+import { isUndefined, isString, arrayToLookup } from '@koine/utils';
+
+let getEventTimestamp = (dateLike) => {
+    const date = new Date(dateLike);
+    date.setHours(0, 0, 0, 0);
+    return date.valueOf() / 1000;
+};
+let getDisplayTime = (date) => date.getHours() +
+    ":" +
+    "0".repeat(2 - date.getMinutes().toString().length) +
+    date.getMinutes();
+let getStartDate = (date, view) => {
+    date.setHours(0, 0, 0);
+    if (view === "month") {
+        date.setDate(1);
+    }
+    else if (view === "week") {
+        date = startOfWeek(date, { weekStartsOn: 1 });
+    }
+    return date;
+};
+let getEndDate = (start, view) => {
+    let end = start;
+    if (view === "month") {
+        end = endOfMonth(start);
+    }
+    else if (view === "week") {
+        end = endOfWeek(start, { weekStartsOn: 1 });
+    }
+    end.setHours(23, 59, 59);
+    return end;
+};
+let getPrevDate = (date, view) => view === "month" ? subMonths(date, 1) : subWeeks(date, 1);
+let getNextDate = (date, view) => view === "month" ? addMonths(date, 1) : addWeeks(date, 1);
+let isTodayInView = (start, end) => isWithinInterval(new Date(), { start, end });
+let addCalendarEvents = (toAdd, toExtend) => {
+    for (const id in toAdd) {
+        const event = toAdd[id];
+        toExtend[id] = event;
+    }
+    return toExtend;
+};
+let getEventsByTimestamp = (events) => {
+    const output = {};
+    for (const uid in events) {
+        const event = events[uid];
+        event.days.forEach((timestamp) => {
+            output[timestamp] = (output[timestamp] || {});
+            output[timestamp][uid] = event;
+        });
+    }
+    return output;
+};
+let getSortedEvents = (events) => {
+    const output = [];
+    for (const uid in events) {
+        output.push(events[uid]);
+    }
+    output.sort((a, b) => {
+        const multi = Number(b.multi) - Number(a.multi);
+        const allDay = Number(b.allDay) - Number(a.allDay);
+        const start = a.start.getTime() - b.start.getTime();
+        const created = a.created.getTime() - b.created.getTime();
+        return multi || allDay || start || created;
+    });
+    return output;
+};
+const FREE_SLOT = 0;
+const BUSY_SLOT = 1;
+let processEventsInView = (eventsMap, calendarView, month, weeks) => {
+    const eventsByTimestamp = getEventsByTimestamp(eventsMap);
+    const eventsList = getSortedEvents(eventsMap);
+    const todayDate = new Date();
+    const todayTimestamp = getEventTimestamp(todayDate);
+    const startedAtTopMap = {};
+    const viewWeeks = [];
+    for (let weekIdx = 0; weekIdx < weeks.length; weekIdx++) {
+        const viewWeek = {
+            props: { key: `week.${weekIdx}` },
+            days: [],
+        };
+        const weekStartDate = weeks[weekIdx];
+        const weekStartDay = weekStartDate.getDate();
+        const weekStartTimestamp = getEventTimestamp(new Date(weekStartDate));
+        const weekEndTimestamp = getEventTimestamp(addDays(new Date(weekStartDate), 6));
+        for (let dayNumber = 0; dayNumber < 7; dayNumber++) {
+            const dayDate = new Date(new Date(weekStartDate).setDate(weekStartDay + dayNumber));
+            const dayTimestamp = getEventTimestamp(dayDate);
+            const $isToday = todayTimestamp === dayTimestamp;
+            const $isOutOfRange = calendarView === "month" && dayDate.getMonth() !== month;
+            const contextualProps = {
+                $isToday,
+                $isOutOfRange,
+            };
+            const viewDay = {
+                props: { key: `day.${dayTimestamp}`, ...contextualProps },
+                timestamp: dayTimestamp + "",
+                label: dayDate.getDate() + "",
+                events: [],
+            };
+            if (eventsByTimestamp?.[dayTimestamp]) {
+                const verticalSlots = Object.keys(eventsByTimestamp[dayTimestamp]).map(() => FREE_SLOT);
+                for (let eventIdx = 0; eventIdx < eventsList.length; eventIdx++) {
+                    const event = eventsList[eventIdx];
+                    let width = 1;
+                    let top = 0;
+                    let firstOfMulti;
+                    if (!event.daysMap[dayTimestamp]) {
+                        continue;
+                    }
+                    if (event.multi) {
+                        width = event.days.filter((t) => t >= weekStartTimestamp && t <= weekEndTimestamp).length;
+                        if (event.days.indexOf(dayTimestamp) === 0 || dayNumber === 0) {
+                            firstOfMulti = true;
+                        }
+                    }
+                    if (startedAtTopMap[event.uid]) {
+                        top = startedAtTopMap[event.uid];
+                    }
+                    else {
+                        for (let verticalIdx = 0; verticalIdx < verticalSlots.length; verticalIdx++) {
+                            const freeOrBusy = verticalSlots[verticalIdx];
+                            if (freeOrBusy !== BUSY_SLOT) {
+                                top = verticalIdx;
+                                break;
+                            }
+                        }
+                    }
+                    verticalSlots[top] = BUSY_SLOT;
+                    if (firstOfMulti) {
+                        startedAtTopMap[event.uid] = top;
+                    }
+                    viewDay.events.push({
+                        key: `event.${dayTimestamp}-${top}`,
+                        ...contextualProps,
+                        ...event,
+                        isPast: todayDate > event.end,
+                        firstOfMulti,
+                        top,
+                        width,
+                    });
+                }
+                for (let i = 0; i < verticalSlots.length; i++) {
+                    if (verticalSlots[i] !== BUSY_SLOT) {
+                        viewDay.events.push({
+                            key: `event.${dayTimestamp}-${i}}`,
+                            placeholder: true,
+                            top: i,
+                        });
+                    }
+                }
+                viewDay.events.sort((a, b) => a.top - b.top);
+            }
+            viewWeek.days.push(viewDay);
+        }
+        viewWeeks.push(viewWeek);
+    }
+    return viewWeeks;
+};
+
+const IconExpand = (props) => {
+    return (jsxs("svg", { viewBox: "0 0 24 24", fill: "currentColor", stroke: "none", ...props, children: [jsx("path", { d: "M0 0h24v24H0z" }), jsx("path", { d: "M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z" })] }));
+};
+const styleBtn = {
+    overflow: "hidden",
+    whiteSpace: "nowrap",
+    textOverflow: "ellipsis",
+};
+let CalendarDaygridCell = ({ eventClicked, setEventClicked, setEventHovered, view, maxEvents, events, calendarsMap, Cell = "div", CellOverflow = "div", CellEvent = "div", CellEventBtn = "div", CellEventTitle = "span", CellEventStart = "span", }) => {
+    const [isExpanded, expand] = useState(false);
+    const eventsWithoutPlaceholders = events.filter((event) => !event.placeholder);
+    return (jsx(Cell, { children: events.map((event, i) => {
+            if (i === maxEvents && !isExpanded) {
+                return (jsxs(CellOverflow, { onClick: () => expand(true), children: [jsx(IconExpand, {}), eventsWithoutPlaceholders.length - maxEvents] }, "overflowMessage" + i));
+            }
+            if (i > maxEvents && !isExpanded)
+                return null;
+            if (event.placeholder) {
+                return (jsx(Fragment, { children: jsx(CellEvent, { "$placeholder": true, children: jsx(CellEventBtn, { "aria-hidden": "true", style: { visibility: "hidden" }, "$placeholder": true, children: jsx(CellEventTitle, { children: "\u00A0" }) }) }) }, event.key));
+            }
+            const styleEvent = {
+                zIndex: event.firstOfMulti ? 1 : 0,
+                position: "relative",
+                width: event.firstOfMulti ? `${100 * event.width}%` : "100%",
+            };
+            if (!calendarsMap[event.calendar.id].on) {
+                styleBtn.display = "none";
+            }
+            const styledProps = {
+                $view: view,
+                $selected: eventClicked?.uid === event.uid,
+                $past: event.isPast,
+                $color: event.color,
+                $isOutOfRange: event.$isOutOfRange,
+                $isToday: event.$isToday,
+            };
+            return (jsx(Fragment, { children: jsx(CellEvent, { style: styleEvent, ...styledProps, children: jsx(CellEventBtn, { role: "button", style: styleBtn, ...styledProps, onClick: () => setEventClicked((prev) => prev?.uid === event.uid ? null : event), onMouseEnter: () => setEventHovered(event), onMouseLeave: () => setEventHovered(null), children: event.allDay ? (jsx(CellEventTitle, { children: event.title })) : (jsxs(Fragment$1, { children: [jsx(CellEventStart, { children: getDisplayTime(event.start) }), jsx(CellEventTitle, { children: event.title })] })) }) }) }, event.key));
+        }) }));
+};
+
+let useDateLocale = (locale, defaultLocale = "en") => {
+    const [data, setData] = useState();
+    const [current, setCurrent] = useState(defaultLocale);
+    useEffect(() => {
+        const importLocaleFile = async () => {
+            const localeToSet = await import('date-fns/locale/en-US');
+            setCurrent(locale || current);
+            setData(localeToSet.enUS);
+        };
+        if (locale !== current) {
+            importLocaleFile();
+        }
+    }, [locale, current]);
+    return data;
+};
+
+let KoineCalendarDaygridNav = ({ range, view, todayInView, handlePrev, handleNext, handleToday, handleView, locale: localeCode, NavRoot = "nav", NavTitle = "div", NavBtns = "div", NavBtnPrev = "button", NavBtnNext = "button", NavBtnToday = "button", NavBtnViewMonth = "button", NavBtnViewWeek = "button", }) => {
+    const [start, end] = range;
+    const locale = useDateLocale(localeCode);
+    const opts = { locale };
+    let formatted = "";
+    if (view === "month") {
+        formatted = format(start, "MMMM yyyy", opts);
+    }
+    if (view === "week") {
+        const inSameMonth = start.getMonth() === end.getMonth();
+        if (inSameMonth) {
+            formatted = format(start, "# MMMM yyyy", opts).replace("#", `${start.getDate()}-${end.getDate()}`);
+        }
+        else {
+            formatted = `${format(start, "d MMMM", opts)} - ${format(end, "d MMMM yyyy", opts)}`;
+        }
+    }
+    return (jsxs(NavRoot, { children: [jsxs(NavBtns, { children: [jsx(NavBtnPrev, { onClick: handlePrev }), jsx(NavBtnNext, { onClick: handleNext }), jsx(NavBtnToday, { onClick: handleToday, disabled: todayInView }), jsx(NavBtnViewMonth, { onClick: () => handleView("month"), disabled: view === "month" }), jsx(NavBtnViewWeek, { onClick: () => handleView("week"), disabled: view === "week" })] }), jsx(NavTitle, { range: range, formatted: formatted })] }));
+};
+
+function getView(range) {
+    const [start, end] = range;
+    const weeks = eachWeekOfInterval({ start, end }, { weekStartsOn: 1 });
+    return {
+        month: start.getMonth(),
+        weeks,
+    };
+}
+let KoineCalendarDaygridTable = ({ locale: localeCode, handlePrev, handleNext, events, dayLabels, view, range, eventClicked, setEventClicked, eventHovered, setEventHovered, calendarsMap = {}, maxEvents = 5, Table = "table", TableHead = "thead", TableHeadCell = "th", TableBody = "tbody", TableBodyRow = "tr", TableBodyCell = "td", TableBodyCellDate = "div", Cell, CellOverflow, CellEvent, CellEventBtn, CellEventTitle, CellEventStart, }) => {
+    const restKoine = {
+        Cell,
+        CellOverflow,
+        CellEvent,
+        CellEventBtn,
+        CellEventTitle,
+        CellEventStart,
+    };
+    const [days, setDays] = useState(dayLabels || [0, 1, 2, 3, 4, 5, 6]);
+    const [weeksEvents, setWeeksEvents] = useState([]);
+    const locale = useDateLocale(localeCode);
+    const { month, weeks } = useMemo(() => getView(range), [range]);
+    const swipeableHandlers = useSwipeable({
+        onSwipedLeft: handleNext,
+        onSwipedRight: handlePrev,
+    });
+    useEffect(() => {
+        setWeeksEvents(processEventsInView(events, view, month, weeks));
+    }, [events, view, month, weeks]);
+    useEffect(() => {
+        if (locale && locale.localize && !dayLabels) {
+            setDays([1, 2, 3, 4, 5, 6, 0].map((i) => locale.localize.day(i, { width: "abbreviated" })));
+        }
+    }, [locale, dayLabels]);
+    return (jsxs(Table, { ...swipeableHandlers, children: [jsx(TableHead, { children: jsx("tr", { children: days.map((day) => (jsx(TableHeadCell, { scope: "column", children: day }, day))) }) }), jsx(TableBody, { children: weeksEvents.map((week, i) => (jsx(TableBodyRow, { ...week.props, children: week.days.map((day) => (jsxs(TableBodyCell, { ...day.props, children: [jsx(TableBodyCellDate, { ...day.props, children: day.label }), day.events.length > 0 && (jsx(CalendarDaygridCell, { eventClicked,
+                                setEventClicked,
+                                eventHovered,
+                                setEventHovered,
+                                view,
+                                maxEvents,
+                                events: day.events,
+                                timestamp: day.timestamp,
+                                calendarsMap, ...restKoine }))] }))) }))) })] }));
+};
+
+let KoineCalendarLegend = ({ calendarsMap = {}, toggleCalendarVisibility, LegendItem = "div", LegendItemStatus = "span", LegendItemLabel = "span", LegendItemEvents = "span", }) => {
+    return (jsx(Fragment$1, { children: Object.entries(calendarsMap).map(([id, calendar]) => (jsxs(LegendItem, { onClick: () => toggleCalendarVisibility(id), "$color": calendar.color, "$empty": calendar.events === 0, disabled: calendar.events === 0, children: [jsx(LegendItemStatus, { children: calendar.on ? "\u2b24" : "\u2b58" }), jsx(LegendItemLabel, { children: calendar.name }), jsx(LegendItemEvents, { children: calendar.events })] }, "CalendarLegend." + id))) }));
+};
+
+const baseURL = "https://www.googleapis.com/calendar/v3/calendars/";
+let getCalendarsEventsFromGoogle = async ({ calendars, ...options }) => {
+    const allEvents = {};
+    await Promise.all(calendars.map(async (calendar) => {
+        const events = await getCalendarEventsFromGoogle({
+            calendar,
+            ...options,
+        });
+        addCalendarEvents(events, allEvents);
+    }));
+    return allEvents;
+};
+async function getCalendarEventsFromGoogle({ apiKey, calendar, timeZone = "", start, end, }) {
+    const events = {};
+    const params = new URLSearchParams({
+        calendarId: calendar.id,
+        timeZone,
+        singleEvents: "true",
+        maxAttendees: "1",
+        maxResults: "9999",
+        sanitizeHtml: "true",
+        timeMin: start.toISOString(),
+        timeMax: end.toISOString(),
+        key: apiKey || process.env["GOOGLE_CALENDAR_API_KEY"] || "",
+    }).toString();
+    const url = baseURL + calendar.id + "/events?" + params;
+    try {
+        const response = await fetch(url, { method: "GET" });
+        const data = (await response.json());
+        calendar.name = calendar.name || data.summary;
+        data.items.forEach((googleEvent) => {
+            const event = transformCalendarEventFromGoogle(googleEvent, calendar);
+            events[event.uid] = event;
+        });
+    }
+    catch (e) {
+    }
+    return events;
+}
+function transformCalendarEventFromGoogle(event, calendar) {
+    const created = new Date(event.created);
+    const link = event.htmlLink;
+    const title = event.summary;
+    const status = event.status;
+    const start = new Date(event.start.date || event.start.dateTime);
+    let end = new Date(event.end.date || event.end.dateTime);
+    const color = calendar.color;
+    const allDay = isUndefined(event.end.dateTime) && isString(event.end.date);
+    const location = event.location || "";
+    const description = event.description || "";
+    const uid = created.getTime() + "" + start.getTime();
+    if (allDay && end > start) {
+        end = subDays(end, 1);
+        end.setHours(23, 59, 59);
+    }
+    const days = getDays();
+    const daysMap = arrayToLookup(days);
+    const multi = days.length > 1;
+    function getDays() {
+        const from = new Date(start);
+        const to = new Date(end);
+        const days = [getEventTimestamp(from)];
+        while (differenceInDays(to, from)) {
+            from.setDate(from.getDate() + 1);
+            days.push(getEventTimestamp(from));
+        }
+        return days;
+    }
+    return {
+        calendar,
+        created,
+        link,
+        title,
+        status,
+        start,
+        end,
+        days,
+        daysMap,
+        multi,
+        color,
+        allDay,
+        location,
+        description,
+        uid,
+    };
+}
+
+let useCalendar = ({ locale, apiKey, calendars, events: initialEvents, start: initialStart, end: initialEnd, view: initialView = "month", timeZone = "", onError, }) => {
+    const [view, setView] = useState(initialView);
+    const start = initialStart || getStartDate(new Date(), view);
+    const end = initialEnd || getEndDate(start, view);
+    const [range, setRange] = useState([start, end]);
+    const [todayInView, setTodayInView] = useState(isTodayInView(start, end));
+    const [events, setEvents] = useState(initialEvents || {});
+    const [eventHovered, setEventHovered] = useState(null);
+    const [eventClicked, setEventClicked] = useState(null);
+    const [calendarsMap, updateCalendars] = useReducer((state, action) => {
+        const { type } = action;
+        switch (type) {
+            case "events": {
+                const events = action.payload;
+                return Object.entries(state).reduce((map, [id, calendar]) => {
+                    map[id] = {
+                        ...calendar,
+                        events: events[id] || 0,
+                    };
+                    return map;
+                }, {});
+            }
+            case "visibility": {
+                const visible = action.payload;
+                if (typeof visible === "string") {
+                    return {
+                        ...state,
+                        [visible]: {
+                            ...state[visible],
+                            on: !state[visible].on,
+                        },
+                    };
+                }
+                else {
+                    return Object.entries(state).reduce((map, [id, calendar]) => {
+                        map[id] = {
+                            ...calendar,
+                            on: visible.indexOf(id) > -1,
+                        };
+                        return map;
+                    }, {});
+                }
+            }
+            default:
+                return state;
+        }
+    }, calendars.reduce((map, calendar) => {
+        map[calendar.id] = {
+            ...calendar,
+            name: calendar.name || "",
+            on: true,
+            events: 0,
+        };
+        return map;
+    }, {}));
+    const toggleCalendarVisibility = useCallback((idOrIds) => {
+        updateCalendars({ type: "visibility", payload: idOrIds });
+    }, [updateCalendars]);
+    const updateCalendarsBasedOnEvents = useCallback((events) => {
+        const payload = {};
+        for (const uid in events) {
+            const { id } = events[uid].calendar;
+            payload[id] = payload[id] || 0;
+            payload[id]++;
+        }
+        updateCalendars({ type: "events", payload });
+    }, []);
+    const loadCalendars = useCallback(async (calendars, start, end) => {
+        try {
+            const newEvents = await getCalendarsEventsFromGoogle({
+                apiKey,
+                calendars,
+                timeZone,
+                start,
+                end,
+            });
+            setEvents(newEvents);
+        }
+        catch (e) {
+            if (onError)
+                onError(e);
+        }
+    }, [setEvents, apiKey, timeZone, onError]);
+    const handleToday = useCallback(() => {
+        const [start, end] = range;
+        const newStart = getStartDate(new Date(), view);
+        const newEnd = getEndDate(newStart, view);
+        setRange([newStart, newEnd]);
+        if (start.getTime() !== newStart.getTime() ||
+            end.getTime() !== newEnd.getTime()) {
+            setEventClicked(null);
+            setEventHovered(null);
+        }
+    }, [view, range]);
+    const handlePrev = useCallback(() => {
+        setRange(([start]) => {
+            const newStart = getPrevDate(start, view);
+            const newEnd = getEndDate(newStart, view);
+            return [newStart, newEnd];
+        });
+        setEventClicked(null);
+        setEventHovered(null);
+    }, [view]);
+    const handleNext = useCallback(() => {
+        setRange(([start]) => {
+            const newStart = getNextDate(start, view);
+            const newEnd = getEndDate(newStart, view);
+            return [newStart, newEnd];
+        });
+        setEventClicked(null);
+        setEventHovered(null);
+    }, [view]);
+    const handleView = useCallback((newView) => {
+        const newStart = getStartDate(start, newView);
+        const newEnd = getEndDate(newStart, newView);
+        setRange([newStart, newEnd]);
+        setView(newView);
+        setEventClicked(null);
+        setEventHovered(null);
+    }, [start]);
+    useEffect(() => {
+        const [start, end] = range;
+        loadCalendars(calendars, start, end);
+        setTodayInView(isTodayInView(start, end));
+    }, [range]);
+    useEffect(() => {
+        if (events) {
+            updateCalendarsBasedOnEvents(events);
+        }
+    }, [events, updateCalendarsBasedOnEvents]);
+    useEffect(() => {
+        if (eventClicked) {
+            if (!calendarsMap[eventClicked.calendar.id].on) {
+                setEventClicked(null);
+            }
+        }
+    }, [calendarsMap, eventClicked, setEventClicked]);
+    return {
+        view,
+        eventClicked,
+        setEventClicked,
+        eventHovered,
+        setEventHovered,
+        getDaygridNavProps: () => ({
+            locale,
+            handlePrev,
+            handleNext,
+            handleToday,
+            handleView,
+            todayInView,
+            range,
+            view,
+        }),
+        getDaygridTableProps: () => ({
+            locale,
+            events,
+            eventClicked,
+            setEventClicked,
+            eventHovered,
+            setEventHovered,
+            handlePrev,
+            handleNext,
+            calendarsMap,
+            range,
+            view,
+        }),
+        getLegendProps: () => ({
+            calendarsMap,
+            toggleCalendarVisibility,
+        }),
+    };
+};
+
+export { CalendarDaygridCell, KoineCalendarDaygridNav, KoineCalendarDaygridTable, KoineCalendarLegend, useCalendar, useDateLocale };

package/classed.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./classed";
+export { default } from "./classed";

package/classed.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./classed.cjs.js').default;

package/classed.cjs.js

@@ -0,0 +1,48 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var react = require('react');
+
+let classed = (component) => {
+    const type = component.type || component;
+    return function (strings, ...args) {
+        const WrappedComponent = react.forwardRef(function (props, ref) {
+            const argResolved = args
+                .map((arg, index) => {
+                let result = "";
+                if (typeof arg === "function") {
+                    result = arg(props);
+                }
+                else if (typeof arg !== "undefined") {
+                    result = arg.toString();
+                }
+                return strings[index] + result;
+            })
+                .join("");
+            const isNativeHtmlElement = typeof type === "string";
+            const propsToForward = isNativeHtmlElement
+                ? {}
+                : props;
+            if (isNativeHtmlElement) {
+                for (const key in props) {
+                    if (!key.startsWith("$")) {
+                        propsToForward[key] = props[key];
+                    }
+                }
+            }
+            let className = argResolved || strings[0];
+            className = className.match(/class="([^"]*)/)?.[1] || className;
+            className += props?.className ? " " + props?.className : "";
+            return react.createElement(type, {
+                ...propsToForward,
+                className: className || undefined,
+                ref,
+            });
+        });
+        return WrappedComponent;
+    };
+};
+
+exports.classed = classed;
+exports["default"] = classed;

package/classed.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './classed.cjs.js';
+export { _default as default } from './classed.cjs.default.js';

package/classed.d.ts

@@ -4,5 +4,5 @@ type ClassedAugmentedProps<Props> = Props & {
     ref?: React.Ref<any>;
 };
 type ClassedFinalProps<Props, Component> = Component extends React.ReactHTML ? React.HTMLProps<Component> & ClassedAugmentedProps<Props> : ClassedAugmentedProps<Props>;
-export declare let classed: <Props, Component extends React.ElementType<any, keyof React.JSX.IntrinsicElements> = any>(component: Component) => (strings: TemplateStringsArray, ...args: string[] | ((props: Props) => string)[]) => React.ForwardRefExoticComponent<React.PropsWithoutRef<ClassedFinalProps<Props, Component>> & React.RefAttributes<Component>>;
+export declare let classed: <Props, Component extends React.ElementType<any, keyof React.JSX.IntrinsicElements> = any>(component: Component) => (strings: TemplateStringsArray, ...args: ((props: Props) => string)[] | string[]) => React.ForwardRefExoticComponent<React.PropsWithoutRef<ClassedFinalProps<Props, Component>> & React.RefAttributes<Component>>;
 export default classed;

package/classed.esm.js

@@ -0,0 +1,43 @@
+import { forwardRef, createElement } from 'react';
+
+let classed = (component) => {
+    const type = component.type || component;
+    return function (strings, ...args) {
+        const WrappedComponent = forwardRef(function (props, ref) {
+            const argResolved = args
+                .map((arg, index) => {
+                let result = "";
+                if (typeof arg === "function") {
+                    result = arg(props);
+                }
+                else if (typeof arg !== "undefined") {
+                    result = arg.toString();
+                }
+                return strings[index] + result;
+            })
+                .join("");
+            const isNativeHtmlElement = typeof type === "string";
+            const propsToForward = isNativeHtmlElement
+                ? {}
+                : props;
+            if (isNativeHtmlElement) {
+                for (const key in props) {
+                    if (!key.startsWith("$")) {
+                        propsToForward[key] = props[key];
+                    }
+                }
+            }
+            let className = argResolved || strings[0];
+            className = className.match(/class="([^"]*)/)?.[1] || className;
+            className += props?.className ? " " + props?.className : "";
+            return createElement(type, {
+                ...propsToForward,
+                className: className || undefined,
+                ref,
+            });
+        });
+        return WrappedComponent;
+    };
+};
+
+export { classed, classed as default };

package/createUseMediaQueryWidth.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "./createUseMediaQueryWidth";
+export { default } from "./createUseMediaQueryWidth";

package/createUseMediaQueryWidth.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./createUseMediaQueryWidth.cjs.js').default;