@arcanejs/react-toolkit 0.2.0 → 0.3.1

package/dist/data.d.mts

@@ -1,8 +1,24 @@
 import { ReactNode, FC, Context } from 'react';
 import { ZodType } from 'zod';
 
-type ProviderProps = {
+type WithPathChange = {
+    /**
+     * When the file path changes and the file does not yet exist,
+     * should the previous data be stored in the new file
+     * or should the new file be reset to the default value?
+     *
+     * @default 'defaultValue'
+     */
+    onPathChange?: 'transfer' | 'defaultValue';
+};
+type DataFileUsage = WithPathChange & {
+    /**
+     * The path to where the JSON data should be stored,
+     * this will be relative to the current working directory.
+     */
     path: string;
+};
+type ProviderProps = DataFileUsage & {
     children: ReactNode;
 };
 type DataFileUpdater<T> = (update: (current: T) => T) => void;
@@ -21,25 +37,60 @@ type DataFileContext<T> = {
      */
     error: unknown;
 };
-type DataFile<T> = {
+type DataFileDefinition<T> = {
     Provider: FC<ProviderProps>;
     context: Context<DataFileContext<T>>;
+    useDataFile: (props: DataFileUsage) => DataFileCore<T>;
 };
-type DataFileProps<T> = {
-    schema: ZodType<T>;
-    defaultValue: T;
+declare function useDataFileData<T>(dataFile: DataFileDefinition<T>): T;
+declare function useDataFileUpdater<T>(dataFile: DataFileDefinition<T>): DataFileUpdater<T>;
+/**
+ * Convenience hook to use the internal data-file context hook
+ */
+declare function useDataFileContext<T>(dataFile: DataFileDefinition<T>): DataFileContext<T>;
+/**
+ * Convenience hook to use the internal data-file definition hook
+ * in a more react-like manner.
+ */
+declare function useDataFile<T>(dataFile: DataFileDefinition<T>, usage: DataFileUsage): DataFileCore<T>;
+type DataState<T> = {
+    status: 'loading';
     /**
-     * When the file path changes and the file does not yet exist,
-     * should the previous data be stored in the new file
-     * or should the new file be reset to the default value?
+     * The data is not yet loaded, so this will be undefined,
+     * but it's listed here as a property so that the data property can be
+     * directly used without a type-guard that uses `state`.
      *
-     * @default 'defaultValue'
+     * This should hopefully also avoid situations where users may check for
+     * `state === 'ready'` instead of `state !== 'loading'`,
+     * and accidentally avoid displaying data that's available but unsaved.
      */
-    onPathChange?: 'transfer' | 'defaultValue';
+    data: undefined;
+} | {
+    status: 'error';
+    data: T | undefined;
+    error: unknown;
+} | {
+    status: 'ready';
+    data: T;
+};
+type UseDataFileCoreProps<T> = WithPathChange & {
+    schema: ZodType<T>;
+    defaultValue: T;
+    path: string;
+};
+type DataFileCore<T> = {
+    data: DataState<T>;
+    updateData: DataFileUpdater<T>;
+    saveData: () => void;
+};
+/**
+ * Primary hook for & logic for using data files.
+ */
+declare function useDataFileCore<T>({ schema, defaultValue, path, onPathChange, }: UseDataFileCoreProps<T>): DataFileCore<T>;
+type CreateDataFileDefinitionProps<T> = {
+    schema: ZodType<T>;
+    defaultValue: T;
 };
-declare function useDataFileData<T>(dataFile: DataFile<T>): T;
-declare function useDataFileUpdater<T>(dataFile: DataFile<T>): DataFileUpdater<T>;
-declare function useDataFile<T>(dataFile: DataFile<T>): DataFileContext<T>;
-declare function createDataFileSpec<T>({ schema, defaultValue, onPathChange, }: DataFileProps<T>): DataFile<T>;
+declare function createDataFileDefinition<T>({ schema, defaultValue, }: CreateDataFileDefinitionProps<T>): DataFileDefinition<T>;
 
-export { type ProviderProps, createDataFileSpec, useDataFile, useDataFileData, useDataFileUpdater };
+export { type CreateDataFileDefinitionProps, type DataFileContext, type DataFileCore, type DataFileDefinition, type DataFileUpdater, type DataState, type ProviderProps, type UseDataFileCoreProps, createDataFileDefinition, useDataFile, useDataFileContext, useDataFileCore, useDataFileData, useDataFileUpdater };

package/dist/data.d.ts

@@ -1,8 +1,24 @@
 import { ReactNode, FC, Context } from 'react';
 import { ZodType } from 'zod';
 
-type ProviderProps = {
+type WithPathChange = {
+    /**
+     * When the file path changes and the file does not yet exist,
+     * should the previous data be stored in the new file
+     * or should the new file be reset to the default value?
+     *
+     * @default 'defaultValue'
+     */
+    onPathChange?: 'transfer' | 'defaultValue';
+};
+type DataFileUsage = WithPathChange & {
+    /**
+     * The path to where the JSON data should be stored,
+     * this will be relative to the current working directory.
+     */
     path: string;
+};
+type ProviderProps = DataFileUsage & {
     children: ReactNode;
 };
 type DataFileUpdater<T> = (update: (current: T) => T) => void;
@@ -21,25 +37,60 @@ type DataFileContext<T> = {
      */
     error: unknown;
 };
-type DataFile<T> = {
+type DataFileDefinition<T> = {
     Provider: FC<ProviderProps>;
     context: Context<DataFileContext<T>>;
+    useDataFile: (props: DataFileUsage) => DataFileCore<T>;
 };
-type DataFileProps<T> = {
-    schema: ZodType<T>;
-    defaultValue: T;
+declare function useDataFileData<T>(dataFile: DataFileDefinition<T>): T;
+declare function useDataFileUpdater<T>(dataFile: DataFileDefinition<T>): DataFileUpdater<T>;
+/**
+ * Convenience hook to use the internal data-file context hook
+ */
+declare function useDataFileContext<T>(dataFile: DataFileDefinition<T>): DataFileContext<T>;
+/**
+ * Convenience hook to use the internal data-file definition hook
+ * in a more react-like manner.
+ */
+declare function useDataFile<T>(dataFile: DataFileDefinition<T>, usage: DataFileUsage): DataFileCore<T>;
+type DataState<T> = {
+    status: 'loading';
     /**
-     * When the file path changes and the file does not yet exist,
-     * should the previous data be stored in the new file
-     * or should the new file be reset to the default value?
+     * The data is not yet loaded, so this will be undefined,
+     * but it's listed here as a property so that the data property can be
+     * directly used without a type-guard that uses `state`.
      *
-     * @default 'defaultValue'
+     * This should hopefully also avoid situations where users may check for
+     * `state === 'ready'` instead of `state !== 'loading'`,
+     * and accidentally avoid displaying data that's available but unsaved.
      */
-    onPathChange?: 'transfer' | 'defaultValue';
+    data: undefined;
+} | {
+    status: 'error';
+    data: T | undefined;
+    error: unknown;
+} | {
+    status: 'ready';
+    data: T;
+};
+type UseDataFileCoreProps<T> = WithPathChange & {
+    schema: ZodType<T>;
+    defaultValue: T;
+    path: string;
+};
+type DataFileCore<T> = {
+    data: DataState<T>;
+    updateData: DataFileUpdater<T>;
+    saveData: () => void;
+};
+/**
+ * Primary hook for & logic for using data files.
+ */
+declare function useDataFileCore<T>({ schema, defaultValue, path, onPathChange, }: UseDataFileCoreProps<T>): DataFileCore<T>;
+type CreateDataFileDefinitionProps<T> = {
+    schema: ZodType<T>;
+    defaultValue: T;
 };
-declare function useDataFileData<T>(dataFile: DataFile<T>): T;
-declare function useDataFileUpdater<T>(dataFile: DataFile<T>): DataFileUpdater<T>;
-declare function useDataFile<T>(dataFile: DataFile<T>): DataFileContext<T>;
-declare function createDataFileSpec<T>({ schema, defaultValue, onPathChange, }: DataFileProps<T>): DataFile<T>;
+declare function createDataFileDefinition<T>({ schema, defaultValue, }: CreateDataFileDefinitionProps<T>): DataFileDefinition<T>;
 
-export { type ProviderProps, createDataFileSpec, useDataFile, useDataFileData, useDataFileUpdater };
+export { type CreateDataFileDefinitionProps, type DataFileContext, type DataFileCore, type DataFileDefinition, type DataFileUpdater, type DataState, type ProviderProps, type UseDataFileCoreProps, createDataFileDefinition, useDataFile, useDataFileContext, useDataFileCore, useDataFileData, useDataFileUpdater };

package/dist/data.js

@@ -20,8 +20,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/data.tsx
 var data_exports = {};
 __export(data_exports, {
-  createDataFileSpec: () => createDataFileSpec,
+  createDataFileDefinition: () => createDataFileDefinition,
   useDataFile: () => useDataFile,
+  useDataFileContext: () => useDataFileContext,
+  useDataFileCore: () => useDataFileCore,
   useDataFileData: () => useDataFileData,
   useDataFileUpdater: () => useDataFileUpdater
 });
@@ -37,149 +39,189 @@ function useDataFileData(dataFile) {
 function useDataFileUpdater(dataFile) {
   return (0, import_react.useContext)(dataFile.context).updateData;
 }
-function useDataFile(dataFile) {
+function useDataFileContext(dataFile) {
   return (0, import_react.useContext)(dataFile.context);
 }
-function createDataFileSpec({
+function useDataFile(dataFile, usage) {
+  return dataFile.useDataFile(usage);
+}
+function useDataFileCore({
   schema,
   defaultValue,
+  path,
   onPathChange = "defaultValue"
 }) {
-  const context = (0, import_react.createContext)({
-    data: defaultValue,
-    updateData: () => {
-      throw new Error("Data file provider not used");
-    },
-    saveData: () => {
-      throw new Error("Data file provider not used");
-    },
-    error: void 0
+  const state = (0, import_react.useRef)({
+    initialized: false,
+    path: null,
+    data: void 0,
+    previousData: void 0,
+    state: {
+      state: "saved"
+    }
   });
-  const Provider = ({ path, children }) => {
-    const state = (0, import_react.useRef)({
-      path: null,
-      data: void 0,
-      previousData: void 0,
-      state: {
-        state: "saved"
+  (0, import_react.useEffect)(() => {
+    if (!state.current.initialized) {
+      state.current.initialized = true;
+    } else {
+      throw new Error(
+        "Cannot change schema or defaultValue after initialization"
+      );
+    }
+  }, [schema, defaultValue]);
+  const [data, setData] = (0, import_react.useState)({
+    status: "loading",
+    data: void 0
+  });
+  const updateDataFromState = (0, import_react.useMemo)(
+    () => () => {
+      const data2 = state.current.data;
+      if (state.current.state.state === "error") {
+        setData({
+          status: "error",
+          error: state.current.state.error,
+          data: data2
+        });
+        return;
       }
-    });
-    const [data, setData] = (0, import_react.useState)({
-      status: "loading"
-    });
-    const updateDataFromState = (0, import_react.useMemo)(
-      () => () => {
-        const data2 = state.current.data;
-        if (state.current.state.state === "error") {
-          setData({
-            status: "error",
-            error: state.current.state.error,
-            data: data2
-          });
+      if (data2 === void 0) {
+        setData({
+          status: "loading",
+          data: void 0
+        });
+        return;
+      }
+      setData({
+        status: "ready",
+        data: data2
+      });
+    },
+    []
+  );
+  const saveData = (0, import_react.useMemo)(
+    () => (0, import_lodash.throttle)(
+      async () => {
+        if (state.current.state.state === "saved") {
           return;
         }
-        if (data2 === void 0) {
-          setData({
-            status: "loading"
-          });
+        const currentPath = state.current.path;
+        const currentData = state.current.data;
+        if (!currentPath || currentData === void 0) {
           return;
         }
-        setData({
-          status: "ready",
-          data: data2
-        });
-      },
-      []
-    );
-    const requestFileWriteToDisk = (0, import_react.useMemo)(
-      () => (0, import_lodash.throttle)(
-        async () => {
-          if (state.current.state.state === "saved") {
-            return;
-          }
-          const currentPath = state.current.path;
-          const currentData = state.current.data;
-          if (!currentPath || currentData === void 0) {
-            return;
+        try {
+          const json = JSON.stringify(currentData, null, 2);
+          await import_fs.promises.mkdir((0, import_path.dirname)(currentPath), { recursive: true });
+          await import_fs.promises.writeFile(currentPath, json, "utf8");
+          if (state.current.path === currentPath && state.current.data === currentData) {
+            state.current.state = { state: "saved" };
           }
-          try {
-            const json = JSON.stringify(currentData, null, 2);
-            await import_fs.promises.mkdir((0, import_path.dirname)(currentPath), { recursive: true });
-            await import_fs.promises.writeFile(currentPath, json, "utf8");
-            if (state.current.path === currentPath && state.current.data === currentData) {
-              state.current.state = { state: "saved" };
-            }
-          } catch (error) {
-            if (state.current.path === currentPath && state.current.data === currentData) {
-              state.current.state = { state: "error", error };
-              updateDataFromState();
-            }
+        } catch (error) {
+          if (state.current.path === currentPath && state.current.data === currentData) {
+            state.current.state = { state: "error", error };
+            updateDataFromState();
           }
-        },
-        500,
-        {
-          // Write leading so that we always write to disk quickly when
-          // only single things have changed
-          leading: true,
-          // Trailing is important otherwise we may lose data
-          trailing: true
-        }
-      ),
-      []
-    );
-    (0, import_react.useEffect)(() => {
-      state.current = {
-        path,
-        data: void 0,
-        previousData: state.current.data ?? state.current.previousData,
-        state: {
-          state: "saved"
         }
-      };
-      import_fs.promises.readFile(path, "utf8").then((data2) => {
-        const parsedData = schema.parse(JSON.parse(data2));
-        if (state.current.path === path) {
-          state.current.data = parsedData;
-          state.current.state = { state: "saved" };
-          updateDataFromState();
-        }
-      }).catch((error) => {
-        if (state.current.path !== path) {
-          return;
-        }
-        if (error.code === "ENOENT") {
-          console.log("Creating new file");
-          const initialData = onPathChange === "transfer" && state.current.previousData !== void 0 ? state.current.previousData : defaultValue;
-          state.current.data = initialData;
-          state.current.state = { state: "dirty" };
-          requestFileWriteToDisk();
-          updateDataFromState();
-          return;
-        }
-        state.current.state = { state: "error", error };
+      },
+      500,
+      {
+        // Write leading so that we always write to disk quickly when
+        // only single things have changed
+        leading: true,
+        // Trailing is important otherwise we may lose data
+        trailing: true
+      }
+    ),
+    []
+  );
+  (0, import_react.useEffect)(() => {
+    state.current = {
+      ...state.current,
+      path,
+      data: void 0,
+      previousData: state.current.data ?? state.current.previousData,
+      state: {
+        state: "saved"
+      }
+    };
+    import_fs.promises.readFile(path, "utf8").then((data2) => {
+      const parsedData = schema.parse(JSON.parse(data2));
+      if (state.current.path === path) {
+        state.current.data = parsedData;
+        state.current.state = { state: "saved" };
         updateDataFromState();
-      });
-    }, [path]);
-    const updateData = (0, import_react.useMemo)(
-      () => (update) => {
-        if (state.current.path !== path) {
-          return;
-        }
-        if (state.current.data === void 0) {
-          throw new Error("Attempt to update data before it has been loaded");
-        }
-        state.current.data = update(state.current.data);
+      }
+    }).catch((error) => {
+      if (state.current.path !== path) {
+        return;
+      }
+      if (error.code === "ENOENT") {
+        console.log("Creating new file");
+        const initialData = onPathChange === "transfer" && state.current.previousData !== void 0 ? state.current.previousData : defaultValue;
+        state.current.data = initialData;
         state.current.state = { state: "dirty" };
-        requestFileWriteToDisk();
+        saveData();
         updateDataFromState();
-      },
-      [path]
-    );
+        return;
+      }
+      state.current.state = { state: "error", error };
+      updateDataFromState();
+    });
+  }, [path, onPathChange]);
+  const updateData = (0, import_react.useMemo)(
+    () => (update) => {
+      if (state.current.path !== path) {
+        return;
+      }
+      if (state.current.data === void 0) {
+        throw new Error("Attempt to update data before it has been loaded");
+      }
+      state.current.data = update(state.current.data);
+      state.current.state = { state: "dirty" };
+      saveData();
+      updateDataFromState();
+    },
+    [path]
+  );
+  return {
+    data,
+    updateData,
+    saveData
+  };
+}
+function createDataFileDefinition({
+  schema,
+  defaultValue
+}) {
+  const context = (0, import_react.createContext)({
+    data: defaultValue,
+    updateData: () => {
+      throw new Error("Data file provider not used");
+    },
+    saveData: () => {
+      throw new Error("Data file provider not used");
+    },
+    error: void 0
+  });
+  const useDataFile2 = ({
+    path,
+    onPathChange
+  }) => useDataFileCore({
+    schema,
+    defaultValue,
+    path,
+    onPathChange
+  });
+  const Provider = ({ path, onPathChange, children }) => {
+    const { data, updateData, saveData } = useDataFile2({
+      path,
+      onPathChange
+    });
     const providedContext = (0, import_react.useMemo)(
       () => ({
         data: data.status !== "loading" && data.data !== void 0 ? data.data : defaultValue,
         updateData,
-        saveData: requestFileWriteToDisk,
+        saveData,
         error: data.status === "error" ? data.error : void 0
       }),
       [data, updateData]
@@ -191,13 +233,16 @@ function createDataFileSpec({
   };
   return {
     Provider,
-    context
+    context,
+    useDataFile: useDataFile2
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createDataFileSpec,
+  createDataFileDefinition,
   useDataFile,
+  useDataFileContext,
+  useDataFileCore,
   useDataFileData,
   useDataFileUpdater
 });

package/dist/data.mjs

@@ -17,149 +17,189 @@ function useDataFileData(dataFile) {
 function useDataFileUpdater(dataFile) {
   return useContext(dataFile.context).updateData;
 }
-function useDataFile(dataFile) {
+function useDataFileContext(dataFile) {
   return useContext(dataFile.context);
 }
-function createDataFileSpec({
+function useDataFile(dataFile, usage) {
+  return dataFile.useDataFile(usage);
+}
+function useDataFileCore({
   schema,
   defaultValue,
+  path,
   onPathChange = "defaultValue"
 }) {
-  const context = createContext({
-    data: defaultValue,
-    updateData: () => {
-      throw new Error("Data file provider not used");
-    },
-    saveData: () => {
-      throw new Error("Data file provider not used");
-    },
-    error: void 0
+  const state = useRef({
+    initialized: false,
+    path: null,
+    data: void 0,
+    previousData: void 0,
+    state: {
+      state: "saved"
+    }
   });
-  const Provider = ({ path, children }) => {
-    const state = useRef({
-      path: null,
-      data: void 0,
-      previousData: void 0,
-      state: {
-        state: "saved"
+  useEffect(() => {
+    if (!state.current.initialized) {
+      state.current.initialized = true;
+    } else {
+      throw new Error(
+        "Cannot change schema or defaultValue after initialization"
+      );
+    }
+  }, [schema, defaultValue]);
+  const [data, setData] = useState({
+    status: "loading",
+    data: void 0
+  });
+  const updateDataFromState = useMemo(
+    () => () => {
+      const data2 = state.current.data;
+      if (state.current.state.state === "error") {
+        setData({
+          status: "error",
+          error: state.current.state.error,
+          data: data2
+        });
+        return;
       }
-    });
-    const [data, setData] = useState({
-      status: "loading"
-    });
-    const updateDataFromState = useMemo(
-      () => () => {
-        const data2 = state.current.data;
-        if (state.current.state.state === "error") {
-          setData({
-            status: "error",
-            error: state.current.state.error,
-            data: data2
-          });
+      if (data2 === void 0) {
+        setData({
+          status: "loading",
+          data: void 0
+        });
+        return;
+      }
+      setData({
+        status: "ready",
+        data: data2
+      });
+    },
+    []
+  );
+  const saveData = useMemo(
+    () => throttle(
+      async () => {
+        if (state.current.state.state === "saved") {
           return;
         }
-        if (data2 === void 0) {
-          setData({
-            status: "loading"
-          });
+        const currentPath = state.current.path;
+        const currentData = state.current.data;
+        if (!currentPath || currentData === void 0) {
           return;
         }
-        setData({
-          status: "ready",
-          data: data2
-        });
-      },
-      []
-    );
-    const requestFileWriteToDisk = useMemo(
-      () => throttle(
-        async () => {
-          if (state.current.state.state === "saved") {
-            return;
-          }
-          const currentPath = state.current.path;
-          const currentData = state.current.data;
-          if (!currentPath || currentData === void 0) {
-            return;
+        try {
+          const json = JSON.stringify(currentData, null, 2);
+          await fs.mkdir(dirname(currentPath), { recursive: true });
+          await fs.writeFile(currentPath, json, "utf8");
+          if (state.current.path === currentPath && state.current.data === currentData) {
+            state.current.state = { state: "saved" };
           }
-          try {
-            const json = JSON.stringify(currentData, null, 2);
-            await fs.mkdir(dirname(currentPath), { recursive: true });
-            await fs.writeFile(currentPath, json, "utf8");
-            if (state.current.path === currentPath && state.current.data === currentData) {
-              state.current.state = { state: "saved" };
-            }
-          } catch (error) {
-            if (state.current.path === currentPath && state.current.data === currentData) {
-              state.current.state = { state: "error", error };
-              updateDataFromState();
-            }
+        } catch (error) {
+          if (state.current.path === currentPath && state.current.data === currentData) {
+            state.current.state = { state: "error", error };
+            updateDataFromState();
           }
-        },
-        500,
-        {
-          // Write leading so that we always write to disk quickly when
-          // only single things have changed
-          leading: true,
-          // Trailing is important otherwise we may lose data
-          trailing: true
-        }
-      ),
-      []
-    );
-    useEffect(() => {
-      state.current = {
-        path,
-        data: void 0,
-        previousData: state.current.data ?? state.current.previousData,
-        state: {
-          state: "saved"
         }
-      };
-      fs.readFile(path, "utf8").then((data2) => {
-        const parsedData = schema.parse(JSON.parse(data2));
-        if (state.current.path === path) {
-          state.current.data = parsedData;
-          state.current.state = { state: "saved" };
-          updateDataFromState();
-        }
-      }).catch((error) => {
-        if (state.current.path !== path) {
-          return;
-        }
-        if (error.code === "ENOENT") {
-          console.log("Creating new file");
-          const initialData = onPathChange === "transfer" && state.current.previousData !== void 0 ? state.current.previousData : defaultValue;
-          state.current.data = initialData;
-          state.current.state = { state: "dirty" };
-          requestFileWriteToDisk();
-          updateDataFromState();
-          return;
-        }
-        state.current.state = { state: "error", error };
+      },
+      500,
+      {
+        // Write leading so that we always write to disk quickly when
+        // only single things have changed
+        leading: true,
+        // Trailing is important otherwise we may lose data
+        trailing: true
+      }
+    ),
+    []
+  );
+  useEffect(() => {
+    state.current = {
+      ...state.current,
+      path,
+      data: void 0,
+      previousData: state.current.data ?? state.current.previousData,
+      state: {
+        state: "saved"
+      }
+    };
+    fs.readFile(path, "utf8").then((data2) => {
+      const parsedData = schema.parse(JSON.parse(data2));
+      if (state.current.path === path) {
+        state.current.data = parsedData;
+        state.current.state = { state: "saved" };
         updateDataFromState();
-      });
-    }, [path]);
-    const updateData = useMemo(
-      () => (update) => {
-        if (state.current.path !== path) {
-          return;
-        }
-        if (state.current.data === void 0) {
-          throw new Error("Attempt to update data before it has been loaded");
-        }
-        state.current.data = update(state.current.data);
+      }
+    }).catch((error) => {
+      if (state.current.path !== path) {
+        return;
+      }
+      if (error.code === "ENOENT") {
+        console.log("Creating new file");
+        const initialData = onPathChange === "transfer" && state.current.previousData !== void 0 ? state.current.previousData : defaultValue;
+        state.current.data = initialData;
         state.current.state = { state: "dirty" };
-        requestFileWriteToDisk();
+        saveData();
         updateDataFromState();
-      },
-      [path]
-    );
+        return;
+      }
+      state.current.state = { state: "error", error };
+      updateDataFromState();
+    });
+  }, [path, onPathChange]);
+  const updateData = useMemo(
+    () => (update) => {
+      if (state.current.path !== path) {
+        return;
+      }
+      if (state.current.data === void 0) {
+        throw new Error("Attempt to update data before it has been loaded");
+      }
+      state.current.data = update(state.current.data);
+      state.current.state = { state: "dirty" };
+      saveData();
+      updateDataFromState();
+    },
+    [path]
+  );
+  return {
+    data,
+    updateData,
+    saveData
+  };
+}
+function createDataFileDefinition({
+  schema,
+  defaultValue
+}) {
+  const context = createContext({
+    data: defaultValue,
+    updateData: () => {
+      throw new Error("Data file provider not used");
+    },
+    saveData: () => {
+      throw new Error("Data file provider not used");
+    },
+    error: void 0
+  });
+  const useDataFile2 = ({
+    path,
+    onPathChange
+  }) => useDataFileCore({
+    schema,
+    defaultValue,
+    path,
+    onPathChange
+  });
+  const Provider = ({ path, onPathChange, children }) => {
+    const { data, updateData, saveData } = useDataFile2({
+      path,
+      onPathChange
+    });
     const providedContext = useMemo(
       () => ({
         data: data.status !== "loading" && data.data !== void 0 ? data.data : defaultValue,
         updateData,
-        saveData: requestFileWriteToDisk,
+        saveData,
         error: data.status === "error" ? data.error : void 0
       }),
       [data, updateData]
@@ -171,12 +211,15 @@ function createDataFileSpec({
   };
   return {
     Provider,
-    context
+    context,
+    useDataFile: useDataFile2
   };
 }
 export {
-  createDataFileSpec,
+  createDataFileDefinition,
   useDataFile,
+  useDataFileContext,
+  useDataFileCore,
   useDataFileData,
   useDataFileUpdater
 };

package/dist/index.d.mts

@@ -11,7 +11,7 @@ import { Props as Props$7, Timeline as Timeline$1 } from '@arcanejs/toolkit/comp
 import * as React from 'react';
 import { Ref } from 'react';
 
-type Child = JSX.Element | string | null | undefined;
+type Child = JSX.Element | string | null | undefined | boolean;
 type Children = Child | Child[];
 interface LightDeskIntrinsicElements {
     button: Props & {

package/dist/index.d.ts

@@ -11,7 +11,7 @@ import { Props as Props$7, Timeline as Timeline$1 } from '@arcanejs/toolkit/comp
 import * as React from 'react';
 import { Ref } from 'react';
 
-type Child = JSX.Element | string | null | undefined;
+type Child = JSX.Element | string | null | undefined | boolean;
 type Children = Child | Child[];
 interface LightDeskIntrinsicElements {
     button: Props & {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcanejs/react-toolkit",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "private": false,
   "description": "Build web-accessible control interfaces for your long-running Node.js processes",
   "keywords": [
@@ -39,7 +39,6 @@
     "@types/react": "^18",
     "@types/react-reconciler": "^0.28.8",
     "eslint": "^8.57.0",
-    "react-reconciler": "^0.28.0",
     "tsup": "^8.1.0",
     "typescript": "^5.3.3",
     "zod": "^3.23.8",
@@ -49,6 +48,7 @@
   "dependencies": {
     "lodash": "^4.17.21",
     "react": "^18",
+    "react-reconciler": "0.28.0",
     "@arcanejs/toolkit": "^0.2.1"
   },
   "peerDependencies": {