@momo-webplatform/mobase 0.0.3

package/publish/esm/src/components/Toast/use-toast.js

@@ -0,0 +1,127 @@
+// Inspired by react-hot-toast library
+import * as React from "react";
+const TOAST_LIMIT = 1;
+const TOAST_REMOVE_DELAY = 1000000;
+const actionTypes = {
+    ADD_TOAST: "ADD_TOAST",
+    UPDATE_TOAST: "UPDATE_TOAST",
+    DISMISS_TOAST: "DISMISS_TOAST",
+    REMOVE_TOAST: "REMOVE_TOAST",
+};
+let count = 0;
+function genId() {
+    count = (count + 1) % Number.MAX_SAFE_INTEGER;
+    return count.toString();
+}
+const toastTimeouts = new Map();
+const addToRemoveQueue = (toastId) => {
+    if (toastTimeouts.has(toastId)) {
+        return;
+    }
+    const timeout = setTimeout(() => {
+        toastTimeouts.delete(toastId);
+        dispatch({
+            type: "REMOVE_TOAST",
+            toastId: toastId,
+        });
+    }, TOAST_REMOVE_DELAY);
+    toastTimeouts.set(toastId, timeout);
+};
+export const reducer = (state, action) => {
+    switch (action.type) {
+        case "ADD_TOAST":
+            return {
+                ...state,
+                toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
+            };
+        case "UPDATE_TOAST":
+            return {
+                ...state,
+                toasts: state.toasts.map((t) => t.id === action.toast.id ? { ...t, ...action.toast } : t),
+            };
+        case "DISMISS_TOAST": {
+            const { toastId } = action;
+            // ! Side effects ! - This could be extracted into a dismissToast() action,
+            // but I'll keep it here for simplicity
+            if (toastId) {
+                addToRemoveQueue(toastId);
+            }
+            else {
+                state.toasts.forEach((toast) => {
+                    addToRemoveQueue(toast.id);
+                });
+            }
+            return {
+                ...state,
+                toasts: state.toasts.map((t) => t.id === toastId || toastId === undefined
+                    ? {
+                        ...t,
+                        open: false,
+                    }
+                    : t),
+            };
+        }
+        case "REMOVE_TOAST":
+            if (action.toastId === undefined) {
+                return {
+                    ...state,
+                    toasts: [],
+                };
+            }
+            return {
+                ...state,
+                toasts: state.toasts.filter((t) => t.id !== action.toastId),
+            };
+    }
+};
+const listeners = [];
+let memoryState = { toasts: [] };
+function dispatch(action) {
+    memoryState = reducer(memoryState, action);
+    listeners.forEach((listener) => {
+        listener(memoryState);
+    });
+}
+function toast({ ...props }) {
+    const id = genId();
+    const update = (props) => dispatch({
+        type: "UPDATE_TOAST",
+        toast: { ...props, id },
+    });
+    const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id });
+    dispatch({
+        type: "ADD_TOAST",
+        toast: {
+            ...props,
+            id,
+            open: true,
+            onOpenChange: (open) => {
+                if (!open)
+                    dismiss();
+            },
+        },
+    });
+    return {
+        id: id,
+        dismiss,
+        update,
+    };
+}
+function useToast() {
+    const [state, setState] = React.useState(memoryState);
+    React.useEffect(() => {
+        listeners.push(setState);
+        return () => {
+            const index = listeners.indexOf(setState);
+            if (index > -1) {
+                listeners.splice(index, 1);
+            }
+        };
+    }, [state]);
+    return {
+        ...state,
+        toast,
+        dismiss: (toastId) => dispatch({ type: "DISMISS_TOAST", toastId }),
+    };
+}
+export { useToast, toast };

package/publish/esm/src/components/Tooltip/Tooltip.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipArrow: React.ForwardRefExoticComponent<TooltipPrimitive.TooltipArrowProps & React.RefAttributes<SVGSVGElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider, TooltipArrow };

package/publish/esm/src/components/Tooltip/Tooltip.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+import { cn } from "@/lib/utils";
+const TooltipProvider = TooltipPrimitive.Provider;
+const Tooltip = TooltipPrimitive.Root;
+const TooltipTrigger = TooltipPrimitive.Trigger;
+const TooltipArrow = TooltipPrimitive.Arrow;
+const TooltipContent = React.forwardRef(({ className, sideOffset = 4, ...props }, ref) => (_jsx(TooltipPrimitive.Content, { ref: ref, sideOffset: sideOffset, className: cn("z-50 overflow-hidden rounded-md bg-primary px-3 py-1.5 text-xs text-primary-foreground animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2", className), ...props })));
+TooltipContent.displayName = TooltipPrimitive.Content.displayName;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider, TooltipArrow };

package/publish/esm/src/helpers/clone-deep.d.ts

@@ -0,0 +1 @@
+export declare function cloneDeep<T>(source: T): T;

package/publish/esm/src/helpers/clone-deep.js

@@ -0,0 +1,11 @@
+import { isObject } from './is-object';
+export function cloneDeep(source) {
+    if (!isObject(source)) {
+        return source;
+    }
+    const output = {};
+    for (const key in source) {
+        output[key] = cloneDeep(source[key]);
+    }
+    return output;
+}

package/publish/esm/src/helpers/clone-deep.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/publish/esm/src/helpers/clone-deep.spec.js

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { cloneDeep } from './clone-deep';
+describe('Helpers / cloneDeep', () => {
+    it('should clone a simple object', () => {
+        const source = { key: 'value' };
+        const cloned = cloneDeep(source);
+        expect(cloned).toEqual(source); // Check for deep equality
+        expect(cloned).not.toBe(source); // Ensure it's a deep clone, not the same reference
+    });
+    it('should handle null gracefully', () => {
+        const source = null;
+        const cloned = cloneDeep(source);
+        expect(cloned).toBeNull();
+    });
+    it('should handle undefined gracefully', () => {
+        const source = undefined;
+        const cloned = cloneDeep(source);
+        expect(cloned).toBeUndefined();
+    });
+});

package/publish/esm/src/helpers/generic-forward-ref.d.ts

@@ -0,0 +1,5 @@
+import type React from 'react';
+/** This allow the `forwardRef` to be used with generic components */
+type FixedForwardRef = <T, P = {}>(render: (props: P, ref: React.Ref<T>) => JSX.Element) => (props: P & React.RefAttributes<T>) => JSX.Element;
+declare const genericForwardRef: FixedForwardRef;
+export default genericForwardRef;

package/publish/esm/src/helpers/generic-forward-ref.js

@@ -0,0 +1,3 @@
+import { forwardRef } from 'react';
+const genericForwardRef = forwardRef;
+export default genericForwardRef;

package/publish/esm/src/helpers/http.d.ts

@@ -0,0 +1 @@
+export declare const safeResJson: (res: Response) => Promise<any>;

package/publish/esm/src/helpers/http.js

@@ -0,0 +1,6 @@
+export const safeResJson = (res) => {
+    if (res.ok) {
+        return res.json();
+    }
+    throw new Error('Internal server error!');
+};

package/publish/esm/src/helpers/is-client.d.ts

@@ -0,0 +1 @@
+export declare const isClient: () => boolean;

package/publish/esm/src/helpers/is-client.js

@@ -0,0 +1,3 @@
+export const isClient = () => {
+    return typeof window !== 'undefined';
+};

package/publish/esm/src/helpers/is-object.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Check if provided parameter is plain object
+ * @param item
+ * @returns boolean
+ */
+export declare function isObject(item: unknown): item is Record<string, unknown>;

package/publish/esm/src/helpers/is-object.js

@@ -0,0 +1,8 @@
+/**
+ * Check if provided parameter is plain object
+ * @param item
+ * @returns boolean
+ */
+export function isObject(item) {
+    return item !== null && typeof item === 'object' && item.constructor === Object;
+}

package/publish/esm/src/helpers/is-object.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/publish/esm/src/helpers/is-object.spec.js

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { isObject } from './is-object';
+describe('isObject function', () => {
+    it('should return true for an empty object', () => {
+        expect(isObject({})).toBe(true);
+    });
+    it('should return true for a non-empty object', () => {
+        expect(isObject({ key: 'value' })).toBe(true);
+    });
+    it('should return false for a string', () => {
+        expect(isObject('string')).toBe(false);
+    });
+    it('should return false for an array', () => {
+        expect(isObject([1, 2, 3])).toBe(false);
+    });
+    it('should return false for null', () => {
+        expect(isObject(null)).toBe(false);
+    });
+    it('should return false for undefined', () => {
+        expect(isObject(undefined)).toBe(false);
+    });
+});

package/publish/esm/src/helpers/merge-deep.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Merge and deep copy the values of all of the enumerable own properties of target object from source object to a new object
+ * @param target The target object to get properties from.
+ * @param source The source object from which to copy properties.
+ * @return A new merged and deep copied object.
+ */
+export declare function mergeDeep<T extends object, S extends object>(target: T, source: S): T & S;

package/publish/esm/src/helpers/merge-deep.js

@@ -0,0 +1,25 @@
+import { cloneDeep } from './clone-deep';
+import { isObject } from './is-object';
+/**
+ * Merge and deep copy the values of all of the enumerable own properties of target object from source object to a new object
+ * @param target The target object to get properties from.
+ * @param source The source object from which to copy properties.
+ * @return A new merged and deep copied object.
+ */
+export function mergeDeep(target, source) {
+    if (isObject(source) && Object.keys(source).length === 0) {
+        return cloneDeep({ ...target, ...source });
+    }
+    const output = { ...target, ...source };
+    if (isObject(source) && isObject(target)) {
+        for (const key in source) {
+            if (isObject(source[key]) && key in target && isObject(target[key])) {
+                output[key] = mergeDeep(target[key], source[key]);
+            }
+            else {
+                output[key] = isObject(source[key]) ? cloneDeep(source[key]) : source[key];
+            }
+        }
+    }
+    return output;
+}

package/publish/esm/src/helpers/merge-deep.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/publish/esm/src/helpers/merge-deep.spec.js

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+import { mergeDeep } from './merge-deep';
+describe('Helpers / Merge deep', () => {
+    it('should merge keys that do not exist in target', () => {
+        const target = {};
+        const source = { foo: 'bar' };
+        const result = mergeDeep(target, source);
+        expect(result).to.deep.equal({ foo: 'bar' });
+    });
+    it('should merge keys that do not exist in source', () => {
+        const target = { foo: 'bar' };
+        const source = {};
+        const result = mergeDeep(target, source);
+        expect(result).to.deep.equal({ foo: 'bar' });
+    });
+    it('should override target key if source key is identical', () => {
+        const target = { foo: { bar: 'baz' } };
+        const source = { foo: { bar: 'foobar' } };
+        const result = mergeDeep(target, source);
+        expect(result).to.deep.equal({ foo: { bar: 'foobar' } });
+    });
+    it('should merge keys and do not mutate target and source', () => {
+        const target = {
+            foo: { a: 1, b: { c: 2, f: { g: 3 } } },
+            baz: 5,
+        };
+        const source = {
+            foo: { b: { c: 3, d: 3 } },
+            bar: { a: 1 },
+        };
+        const result = mergeDeep(target, source);
+        expect(result).to.deep.equal({ foo: { a: 1, b: { c: 3, d: 3, f: { g: 3 } } }, baz: 5, bar: { a: 1 } });
+        expect(target).to.deep.equal({
+            foo: { a: 1, b: { c: 2, f: { g: 3 } } },
+            baz: 5,
+        });
+        expect(source).to.deep.equal({
+            foo: { b: { c: 3, d: 3 } },
+            bar: { a: 1 },
+        });
+        result.foo.b.c = 97;
+        result.baz = 98;
+        result.bar.a = 99;
+        expect(result).to.deep.equal({ foo: { a: 1, b: { c: 97, d: 3, f: { g: 3 } } }, baz: 98, bar: { a: 99 } });
+        expect(target).to.deep.equal({
+            foo: { a: 1, b: { c: 2, f: { g: 3 } } },
+            baz: 5,
+        });
+        expect(source).to.deep.equal({
+            foo: { b: { c: 3, d: 3 } },
+            bar: { a: 1 },
+        });
+    });
+});

package/publish/esm/src/helpers/omit.d.ts

@@ -0,0 +1 @@
+export declare const omit: <T extends object, K extends string>(keys: readonly K[]) => (obj: T) => Omit<T, K>;

package/publish/esm/src/helpers/omit.js

@@ -0,0 +1,12 @@
+export const omit = (keys) => (obj) => {
+    const result = {};
+    for (const key in obj) {
+        // @ts-expect-error - bypass
+        if (keys.includes(key)) {
+            continue;
+        }
+        // @ts-expect-error - bypass
+        result[key] = obj[key];
+    }
+    return result;
+};

package/publish/esm/src/helpers/omit.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/publish/esm/src/helpers/omit.spec.js

@@ -0,0 +1,7 @@
+import { describe, expect, it } from 'vitest';
+import { omit } from './omit';
+describe('omit', () => {
+    it('should omit keys from object', () => {
+        expect(omit(['a', 'b'])({ a: 'a', b: 'b', c: 'c' })).toEqual({ c: 'c' });
+    });
+});

package/publish/esm/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./components/Accordion";
+export * from "./components/Button";
+export * from "./components/Checkbox";

package/publish/esm/src/index.js

@@ -0,0 +1,3 @@
+export * from "./components/Accordion";
+export * from "./components/Button";
+export * from "./components/Checkbox";

package/publish/esm/src/types/index.d.ts

@@ -0,0 +1,3 @@
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;

package/publish/esm/src/types/index.js

@@ -0,0 +1 @@
+export {};