@simplysm/solid 13.0.75 → 13.0.77

package/tests/components/layout/topbar/TopbarActions.spec.tsx

@@ -1,8 +1,8 @@
 import { render, cleanup } from "@solidjs/testing-library";
 import { describe, it, expect, afterEach, beforeEach } from "vitest";
 import { createSignal, Show } from "solid-js";
-import { Topbar, createTopbarActions } from "../../../../src";
-import { I18nProvider } from "../../../../src/providers/i18n/I18nContext";
+import { Topbar, useTopbarActions } from "../../../../src";
+import { I18nProvider } from "../../../../src/providers/i18n/I18nProvider";
 import { ConfigProvider } from "../../../../src/providers/ConfigContext";
 
 describe("Topbar.Actions component", () => {
@@ -16,7 +16,7 @@ describe("Topbar.Actions component", () => {
 
   it("renders registered actions at Topbar.Actions position", () => {
     function PageWithActions() {
-      createTopbarActions(() => <button>Save</button>);
+      useTopbarActions(() => <button>Save</button>);
       return <div>Page Content</div>;
     }
 
@@ -58,12 +58,12 @@ describe("Topbar.Actions component", () => {
 
   it("releases previous actions and displays new actions when switching components", () => {
     function PageA() {
-      createTopbarActions(() => <button>Save</button>);
+      useTopbarActions(() => <button>Save</button>);
       return <div>Page A</div>;
     }
 
     function PageB() {
-      createTopbarActions(() => <button>Delete</button>);
+      useTopbarActions(() => <button>Delete</button>);
       return <div>Page B</div>;
     }
 

package/tests/components/layout/topbar/{createTopbarActions.spec.tsx → useTopbarActions.spec.tsx}

@@ -1,7 +1,7 @@
 import { render, cleanup } from "@solidjs/testing-library";
 import { describe, it, expect, afterEach } from "vitest";
 import { createSignal, type Accessor, type JSX } from "solid-js";
-import { Topbar, createTopbarActions, useTopbarActionsAccessor } from "../../../../src";
+import { Topbar, useTopbarActions, useTopbarActionsAccessor } from "../../../../src";
 
 // Helper: Extract actions accessor from TopbarContext
 function ActionsReader(props: { onCapture: (actions: Accessor<JSX.Element | undefined>) => void }) {
@@ -11,7 +11,7 @@ function ActionsReader(props: { onCapture: (actions: Accessor<JSX.Element | unde
   return null;
 }
 
-describe("createTopbarActions", () => {
+describe("useTopbarActions", () => {
   afterEach(() => {
     cleanup();
   });
@@ -27,7 +27,7 @@ describe("createTopbarActions", () => {
     ));
 
     function TestChild() {
-      createTopbarActions(() => <button>Save</button>);
+      useTopbarActions(() => <button>Save</button>);
       return null;
     }
 
@@ -46,7 +46,7 @@ describe("createTopbarActions", () => {
     ));
 
     function TestChild() {
-      createTopbarActions(() => <button>Save</button>);
+      useTopbarActions(() => <button>Save</button>);
       return null;
     }
 
@@ -55,13 +55,4 @@ describe("createTopbarActions", () => {
     setShow(false);
     expect(actionsAccessor()).toBeUndefined();
   });
-
-  it("throws error when called without TopbarContainer", () => {
-    expect(() => {
-      render(() => {
-        createTopbarActions(() => <button>Save</button>);
-        return null;
-      });
-    }).toThrow();
-  });
 });

package/tests/helpers/createAppStructure.spec.tsx

@@ -77,32 +77,6 @@ function buildTestStructure<const TItems extends AppStructureItem<string>[]>(opt
 }
 
 describe("createAppStructure", () => {
-  it("returns AppStructureProvider and useAppStructure", () => {
-    createRoot((dispose) => {
-      const { AppStructureProvider, useAppStructure } = createAppStructure(() => ({
-        items: [
-          {
-            code: "home",
-            title: "홈",
-            children: [
-              {
-                code: "user",
-                title: "사용자",
-                component: DummyA,
-                perms: ["use"] as ("use" | "edit")[],
-              },
-            ],
-          },
-        ],
-      }));
-
-      expect(AppStructureProvider).toBeTypeOf("function");
-      expect(useAppStructure).toBeTypeOf("function");
-
-      dispose();
-    });
-  });
-
   describe("usableRoutes", () => {
     it("includes paths and components for all leaf items", () => {
       createRoot((dispose) => {

package/tests/helpers/createSlot.spec.tsx

@@ -0,0 +1,99 @@
+import { describe, it, expect } from "vitest";
+import { createRoot } from "solid-js";
+import { createSlot } from "../../src/helpers/createSlot";
+
+interface TestSlotProps {
+  label: string;
+  value: number;
+}
+
+describe("createSlot", () => {
+  it("returns a [SlotComponent, useSlot] tuple", () => {
+    const [SlotComponent, useSlot] = createSlot<TestSlotProps>();
+    expect(typeof SlotComponent).toBe("function");
+    expect(typeof useSlot).toBe("function");
+  });
+
+  it("useSlot returns [accessor, Provider] tuple", () => {
+    createRoot((dispose) => {
+      const [, useSlot] = createSlot<TestSlotProps>();
+      const [item, Provider] = useSlot();
+      expect(typeof item).toBe("function");
+      expect(typeof Provider).toBe("function");
+      dispose();
+    });
+  });
+
+  it("accessor returns undefined initially", () => {
+    createRoot((dispose) => {
+      const [, useSlot] = createSlot<TestSlotProps>();
+      const [item] = useSlot();
+      expect(item()).toBeUndefined();
+      dispose();
+    });
+  });
+
+  it("registering a SlotComponent via Provider sets item in accessor", () => {
+    createRoot((dispose) => {
+      const [SlotComponent, useSlot] = createSlot<TestSlotProps>();
+      const [item, Provider] = useSlot();
+
+      Provider({
+        get children() {
+          SlotComponent({ label: "alpha", value: 1 });
+          return undefined;
+        },
+      });
+
+      expect(item()).toBeDefined();
+      expect(item()!.label).toBe("alpha");
+      expect(item()!.value).toBe(1);
+      dispose();
+    });
+  });
+
+  it("cleanup removes the registered item from accessor", () => {
+    createRoot((dispose) => {
+      const [SlotComponent, useSlot] = createSlot<TestSlotProps>();
+      const [item, Provider] = useSlot();
+
+      // Mount an inner root that registers a slot item
+      const innerDispose = createRoot((disposeInner) => {
+        Provider({
+          get children() {
+            SlotComponent({ label: "temp", value: 99 });
+            return undefined;
+          },
+        });
+        return disposeInner;
+      });
+
+      expect(item()).toBeDefined();
+
+      // Dispose the inner root — triggers onCleanup in SlotComponent
+      innerDispose();
+
+      expect(item()).toBeUndefined();
+      dispose();
+    });
+  });
+
+  it("throws 'Slot already occupied' when a second SlotComponent is registered", () => {
+    createRoot((dispose) => {
+      const [SlotComponent, useSlot] = createSlot<TestSlotProps>();
+      const [, Provider] = useSlot();
+
+      expect(() => {
+        Provider({
+          get children() {
+            SlotComponent({ label: "first", value: 1 });
+            SlotComponent({ label: "second", value: 2 });
+            return undefined;
+          },
+        });
+      }).toThrow("Slot already occupied");
+
+      dispose();
+    });
+  });
+});

package/tests/helpers/createSlots.spec.tsx

@@ -0,0 +1,100 @@
+import { describe, it, expect } from "vitest";
+import { createRoot } from "solid-js";
+import { createSlots } from "../../src/helpers/createSlots";
+
+interface TestSlotProps {
+  label: string;
+  value: number;
+}
+
+describe("createSlots", () => {
+  it("returns a [SlotComponent, useSlots] tuple", () => {
+    const [SlotComponent, useSlots] = createSlots<TestSlotProps>();
+    expect(typeof SlotComponent).toBe("function");
+    expect(typeof useSlots).toBe("function");
+  });
+
+  it("useSlots returns [accessor, Provider] tuple", () => {
+    createRoot((dispose) => {
+      const [, useSlots] = createSlots<TestSlotProps>();
+      const [items, Provider] = useSlots();
+      expect(typeof items).toBe("function");
+      expect(typeof Provider).toBe("function");
+      dispose();
+    });
+  });
+
+  it("accessor returns empty array initially", () => {
+    createRoot((dispose) => {
+      const [, useSlots] = createSlots<TestSlotProps>();
+      const [items] = useSlots();
+      expect(items()).toEqual([]);
+      dispose();
+    });
+  });
+
+  it("registering a SlotComponent via Provider adds item to accessor", () => {
+    createRoot((dispose) => {
+      const [SlotComponent, useSlots] = createSlots<TestSlotProps>();
+      const [items, Provider] = useSlots();
+
+      Provider({
+        get children() {
+          SlotComponent({ label: "alpha", value: 1 });
+          return undefined;
+        },
+      });
+
+      expect(items()).toHaveLength(1);
+      expect(items()[0].label).toBe("alpha");
+      expect(items()[0].value).toBe(1);
+      dispose();
+    });
+  });
+
+  it("registering multiple SlotComponents adds all items to accessor", () => {
+    createRoot((dispose) => {
+      const [SlotComponent, useSlots] = createSlots<TestSlotProps>();
+      const [items, Provider] = useSlots();
+
+      Provider({
+        get children() {
+          SlotComponent({ label: "first", value: 10 });
+          SlotComponent({ label: "second", value: 20 });
+          return undefined;
+        },
+      });
+
+      expect(items()).toHaveLength(2);
+      expect(items()[0].label).toBe("first");
+      expect(items()[1].label).toBe("second");
+      dispose();
+    });
+  });
+
+  it("cleanup removes the registered item from accessor", () => {
+    createRoot((dispose) => {
+      const [SlotComponent, useSlots] = createSlots<TestSlotProps>();
+      const [items, Provider] = useSlots();
+
+      // Mount an inner root that registers a slot item
+      const innerDispose = createRoot((disposeInner) => {
+        Provider({
+          get children() {
+            SlotComponent({ label: "temp", value: 42 });
+            return undefined;
+          },
+        });
+        return disposeInner;
+      });
+
+      expect(items()).toHaveLength(1);
+
+      // Dispose the inner root — triggers onCleanup in SlotComponent
+      innerDispose();
+
+      expect(items()).toEqual([]);
+      dispose();
+    });
+  });
+});

package/tests/hooks/createControllableSignal.spec.ts

@@ -66,17 +66,6 @@ describe("createControllableSignal hook", () => {
       });
     });
 
-    it("value() is set to initial value when onChange is not provided", () => {
-      createRoot((dispose) => {
-        const [value] = createControllableSignal({
-          value: () => "initial",
-          onChange: () => undefined,
-        });
-
-        expect(value()).toBe("initial");
-        dispose();
-      });
-    });
   });
 
   describe("Function-form setter", () => {
@@ -133,45 +122,6 @@ describe("createControllableSignal hook", () => {
   });
 
   describe("Support various types", () => {
-    it("supports number type", () => {
-      createRoot((dispose) => {
-        const [value, setValue] = createControllableSignal({
-          value: () => 0,
-          onChange: () => undefined,
-        });
-
-        setValue(42);
-        expect(value()).toBe(42);
-        dispose();
-      });
-    });
-
-    it("supports string type", () => {
-      createRoot((dispose) => {
-        const [value, setValue] = createControllableSignal({
-          value: () => "hello",
-          onChange: () => undefined,
-        });
-
-        setValue("world");
-        expect(value()).toBe("world");
-        dispose();
-      });
-    });
-
-    it("supports object type", () => {
-      createRoot((dispose) => {
-        const [value, setValue] = createControllableSignal({
-          value: () => ({ count: 0 }),
-          onChange: () => undefined,
-        });
-
-        setValue({ count: 10 });
-        expect(value()).toEqual({ count: 10 });
-        dispose();
-      });
-    });
-
     it("can store function wrapped in object", () => {
       createRoot((dispose) => {
         const fn1 = () => "first";

package/tests/hooks/createControllableStore.spec.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect, vi } from "vitest";
+import { createRoot } from "solid-js";
+import { createControllableStore } from "../../src/hooks/createControllableStore";
+import { DateTime } from "@simplysm/core-common";
+
+describe("createControllableStore", () => {
+  it("calls onChange when store value changes", () => {
+    const onChange = vi.fn();
+
+    createRoot((dispose) => {
+      const [store, setStore] = createControllableStore<{ name: string }>({
+        value: () => ({ name: "a" }),
+        onChange: () => onChange,
+      });
+
+      expect(store.name).toBe("a");
+
+      setStore("name", "b");
+
+      expect(onChange).toHaveBeenCalledTimes(1);
+      expect(onChange).toHaveBeenCalledWith(expect.objectContaining({ name: "b" }));
+      dispose();
+    });
+  });
+
+  it("does not call onChange when value is unchanged", () => {
+    const onChange = vi.fn();
+
+    createRoot((dispose) => {
+      const [, setStore] = createControllableStore<{ name: string }>({
+        value: () => ({ name: "a" }),
+        onChange: () => onChange,
+      });
+
+      setStore("name", "a");
+
+      expect(onChange).not.toHaveBeenCalled();
+      dispose();
+    });
+  });
+
+  it("correctly detects changes in DateTime values", () => {
+    const onChange = vi.fn();
+
+    createRoot((dispose) => {
+      const dt1 = new DateTime(2025, 1, 1, 0, 0, 0);
+      const dt2 = new DateTime(2025, 6, 15, 12, 30, 0);
+
+      const [, setStore] = createControllableStore<{ date: DateTime }>({
+        value: () => ({ date: dt1 }),
+        onChange: () => onChange,
+      });
+
+      // Change to different DateTime — should trigger onChange
+      setStore("date", dt2);
+      expect(onChange).toHaveBeenCalledTimes(1);
+
+      onChange.mockClear();
+
+      // Set same tick DateTime — should NOT trigger onChange
+      setStore("date", new DateTime(dt2.tick));
+      expect(onChange).not.toHaveBeenCalled();
+
+      dispose();
+    });
+  });
+});

package/tests/hooks/createMountTransition.spec.ts

@@ -15,15 +15,6 @@ describe("createMountTransition", () => {
     vi.useRealTimers();
   });
 
-  it("mounted=false and animating=false when open=false", () => {
-    createRoot((dispose) => {
-      const { mounted, animating } = createMountTransition(() => false);
-      expect(mounted()).toBe(false);
-      expect(animating()).toBe(false);
-      dispose();
-    });
-  });
-
   it("mounted=true when open changes to true", async () => {
     const outerDispose = await new Promise<() => void>((resolveDispose) => {
       void createRoot(async (dispose) => {

package/tests/hooks/useLocalStorage.spec.tsx

@@ -13,40 +13,6 @@ describe("useLocalStorage", () => {
     localStorage.clear();
   });
 
-  it("returns undefined when no initial value is provided", () => {
-    let value!: () => string | undefined;
-
-    function TestComponent() {
-      [value] = useLocalStorage<string>("test-key");
-      return <div />;
-    }
-
-    render(() => (
-      <ConfigContext.Provider value={{ clientName: "testApp" }}>
-        <TestComponent />
-      </ConfigContext.Provider>
-    ));
-
-    expect(value()).toBeUndefined();
-  });
-
-  it("returns provided initial value", () => {
-    let value!: () => string | undefined;
-
-    function TestComponent() {
-      [value] = useLocalStorage("test-key", "default");
-      return <div />;
-    }
-
-    render(() => (
-      <ConfigContext.Provider value={{ clientName: "testApp" }}>
-        <TestComponent />
-      </ConfigContext.Provider>
-    ));
-
-    expect(value()).toBe("default");
-  });
-
   it("returns existing value from localStorage if available", () => {
     localStorage.setItem("testApp.test-key", JSON.stringify("stored"));
 

package/tests/hooks/useLogger.spec.tsx

@@ -1,7 +1,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { cleanup, renderHook } from "@solidjs/testing-library";
 import { useLogger } from "../../src/hooks/useLogger";
-import { LoggerProvider } from "../../src/providers/LoggerContext";
+import { LoggerProvider } from "../../src/providers/LoggerProvider";
 import { consola } from "consola";
 
 function loggerWrapper() {
@@ -17,15 +17,6 @@ describe("useLogger", () => {
     cleanup();
   });
 
-  it("should return a logger object with log, info, warn, error, configure methods", () => {
-    const { result } = renderHook(() => useLogger(), { wrapper: loggerWrapper() });
-    expect(typeof result.log).toBe("function");
-    expect(typeof result.info).toBe("function");
-    expect(typeof result.warn).toBe("function");
-    expect(typeof result.error).toBe("function");
-    expect(typeof result.configure).toBe("function");
-  });
-
   it("should call consola when no LoggerProvider is present", () => {
     const consolaSpy = {
       log: vi.spyOn(consola, "log").mockImplementation(() => {}),
@@ -86,14 +77,6 @@ describe("useLogger", () => {
     expect(writeSpy).toHaveBeenCalledWith("error", "d");
   });
 
-  it("should throw when configure() is called without LoggerProvider", () => {
-    const { result } = renderHook(() => useLogger());
-
-    expect(() => result.configure(() => ({ write: vi.fn() }))).toThrow(
-      "configure() can only be used inside LoggerProvider",
-    );
-  });
-
   it("should chain decorators — origin receives the previous adapter", () => {
     const firstSpy = vi.fn();
     const secondSpy = vi.fn();

package/tests/hooks/usePrint.spec.tsx

@@ -2,36 +2,13 @@ import { render } from "@solidjs/testing-library";
 import { describe, it, expect, vi } from "vitest";
 import { onMount } from "solid-js";
 import { BusyProvider } from "../../src/components/feedback/busy/BusyProvider";
-import { PrintProvider } from "../../src/components/feedback/print/PrintProvider";
-import { usePrint } from "../../src/components/feedback/print/PrintContext";
+import { PrintProvider, usePrint, usePrintInstance } from "../../src/components/feedback/print/PrintProvider";
 import { Print } from "../../src/components/feedback/print/Print";
-import { usePrintInstance } from "../../src/components/feedback/print/PrintInstanceContext";
 
 // Mock window.print
 vi.stubGlobal("print", vi.fn());
 
 describe("usePrint", () => {
-  describe("Hook interface", () => {
-    it("returns toPrinter and toPdf functions", () => {
-      let result: ReturnType<typeof usePrint> | undefined;
-
-      render(() => (
-        <BusyProvider>
-          <PrintProvider>
-            {(() => {
-              result = usePrint();
-              return <div />;
-            })()}
-          </PrintProvider>
-        </BusyProvider>
-      ));
-
-      expect(result).toBeDefined();
-      expect(typeof result!.toPrinter).toBe("function");
-      expect(typeof result!.toPdf).toBe("function");
-    });
-  });
-
   describe("toPrinter", () => {
     it("prints simple content without Print", async () => {
       let printFn: ReturnType<typeof usePrint>["toPrinter"] | undefined;

package/tests/hooks/useSyncConfig.spec.tsx

@@ -6,7 +6,7 @@ import {
   SyncStorageProvider,
   useSyncStorage,
   type StorageAdapter,
-} from "../../src/providers/SyncStorageContext";
+} from "../../src/providers/SyncStorageProvider";
 
 /** Helper to configure adapter within SyncStorageProvider and render children */
 function ConfigureStorage(props: { storage: StorageAdapter; children: any }) {
@@ -26,23 +26,6 @@ describe("useSyncConfig", () => {
     localStorage.clear();
   });
 
-  it("should initialize with default value when no stored value exists", () => {
-    let value!: () => string;
-
-    function TestComponent() {
-      [value] = useSyncConfig("test-key", "default");
-      return <div>{value()}</div>;
-    }
-
-    render(() => (
-      <ConfigProvider clientName="testApp">
-        <TestComponent />
-      </ConfigProvider>
-    ));
-
-    expect(value()).toBe("default");
-  });
-
   it("should load value from localStorage when no SyncStorageProvider", () => {
     localStorage.setItem("testApp.test-key", JSON.stringify("stored"));
 

package/tests/providers/ErrorLoggerProvider.spec.tsx

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, afterEach } from "vitest";
 import { render, cleanup } from "@solidjs/testing-library";
 import { ErrorLoggerProvider } from "../../src/providers/ErrorLoggerProvider";
-import { LoggerProvider, type LogAdapter } from "../../src/providers/LoggerContext";
+import { LoggerProvider, type LogAdapter } from "../../src/providers/LoggerProvider";
 import { useLogger } from "../../src/hooks/useLogger";
 
 /** Helper to configure adapter within LoggerProvider and render children */
@@ -16,16 +16,6 @@ describe("ErrorLoggerProvider", () => {
     cleanup();
   });
 
-  it("renders children correctly", () => {
-    const { getByText } = render(() => (
-      <ErrorLoggerProvider>
-        <div>child content</div>
-      </ErrorLoggerProvider>
-    ));
-
-    expect(getByText("child content")).toBeDefined();
-  });
-
   it("captures window error events and calls logger.error", () => {
     const writeSpy = vi.fn();
     const adapter: LogAdapter = { write: writeSpy };

package/tests/providers/ServiceClientContext.spec.tsx

@@ -1,31 +1,13 @@
 import { describe, it, expect, beforeEach } from "vitest";
-import { createRoot } from "solid-js";
 import { render } from "@solidjs/testing-library";
 import {
   useServiceClient,
   type ServiceClientContextValue,
-} from "../../src/providers/ServiceClientContext";
+} from "../../src/providers/ServiceClientProvider";
 import { ServiceClientProvider } from "../../src/providers/ServiceClientProvider";
 import { NotificationProvider } from "../../src/components/feedback/notification/NotificationProvider";
 import { ConfigContext } from "../../src/providers/ConfigContext";
-import { I18nProvider } from "../../src/providers/i18n/I18nContext";
-
-describe("ServiceClientContext", () => {
-  beforeEach(() => {
-    localStorage.setItem("testApp.i18n-locale", JSON.stringify("en"));
-  });
-
-  describe("useServiceClient", () => {
-    it("throws error when used without Provider", () => {
-      createRoot((dispose) => {
-        expect(() => useServiceClient()).toThrow(
-          "useServiceClient can only be used inside ServiceClientProvider",
-        );
-        dispose();
-      });
-    });
-  });
-});
+import { I18nProvider } from "../../src/providers/i18n/I18nProvider";
 
 describe("ServiceClientProvider", () => {
   beforeEach(() => {