@iowas/toolpad 1.0.0

package/dist/nextjs.mjs

@@ -0,0 +1,106 @@
+import {
+  AppProvider
+} from "./chunk-LUTZBKSG.mjs";
+import {
+  asArray
+} from "./chunk-UNVYOWC2.mjs";
+import {
+  __objRest,
+  __spreadValues
+} from "./chunk-3JWXE2JW.mjs";
+
+// src/toolpad-core/nextjs/NextAppProvider.tsx
+import { useRouter as useRouter3 } from "next/compat/router.js";
+
+// src/toolpad-core/nextjs/NextAppProviderApp.tsx
+import * as React from "react";
+import NextLink from "next/link.js";
+import { usePathname, useSearchParams, useRouter } from "next/navigation.js";
+import { jsx } from "react/jsx-runtime";
+var Link = React.forwardRef((props, ref) => {
+  const _a = props, { href, history } = _a, rest = __objRest(_a, ["href", "history"]);
+  return /* @__PURE__ */ jsx(NextLink, __spreadValues({ ref, href, replace: history === "replace" }, rest));
+});
+function NextAppProviderApp(props) {
+  const pathname = usePathname();
+  const searchParams = useSearchParams();
+  const { push, replace } = useRouter();
+  const navigate = React.useCallback(
+    (url, { history = "auto" } = {}) => {
+      if (history === "auto" || history === "push") {
+        return push(String(url));
+      }
+      if (history === "replace") {
+        return replace(String(url));
+      }
+      throw new Error(`Invalid history option: ${history}`);
+    },
+    [push, replace]
+  );
+  const routerImpl = React.useMemo(
+    () => ({
+      pathname,
+      searchParams,
+      navigate,
+      Link
+    }),
+    [pathname, navigate, searchParams]
+  );
+  return /* @__PURE__ */ jsx(AppProvider, __spreadValues({ router: routerImpl }, props));
+}
+
+// src/toolpad-core/nextjs/NextAppProviderPages.tsx
+import * as React2 from "react";
+import NextLink2 from "next/link.js";
+import { useRouter as useRouter2 } from "next/router.js";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var Link2 = React2.forwardRef((props, ref) => {
+  const _a = props, { href, history } = _a, rest = __objRest(_a, ["href", "history"]);
+  return /* @__PURE__ */ jsx2(NextLink2, __spreadValues({ ref, href, replace: history === "replace" }, rest));
+});
+function NextAppProviderPages(props) {
+  const { push, replace, asPath, query } = useRouter2();
+  const search = React2.useMemo(() => {
+    const params = new URLSearchParams();
+    Object.entries(query != null ? query : {}).forEach(([key, value]) => {
+      asArray(value != null ? value : []).forEach((v) => {
+        params.append(key, v);
+      });
+    });
+    return params.toString();
+  }, [query]);
+  const searchParams = React2.useMemo(() => new URLSearchParams(search), [search]);
+  const navigate = React2.useCallback(
+    (url, { history = "auto" } = {}) => {
+      if (history === "auto" || history === "push") {
+        return push(String(url));
+      }
+      if (history === "replace") {
+        return replace(String(url));
+      }
+      throw new Error(`Invalid history option: ${history}`);
+    },
+    [push, replace]
+  );
+  const routerImpl = React2.useMemo(
+    () => ({
+      pathname: asPath.split("?")[0],
+      searchParams,
+      navigate,
+      Link: Link2
+    }),
+    [asPath, navigate, searchParams]
+  );
+  return /* @__PURE__ */ jsx2(AppProvider, __spreadValues({ router: routerImpl }, props));
+}
+
+// src/toolpad-core/nextjs/NextAppProvider.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function NextAppProvider(props) {
+  const router = useRouter3();
+  const AppProvider2 = router ? NextAppProviderPages : NextAppProviderApp;
+  return /* @__PURE__ */ jsx3(AppProvider2, __spreadValues({}, props));
+}
+export {
+  NextAppProvider
+};

package/dist/utils.d.mts

@@ -0,0 +1,98 @@
+import * as React from 'react';
+
+declare function asArray<T>(maybeArray: T | T[]): T[];
+type PropertiesOf<P> = Extract<keyof P, string>;
+type Require<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+type Ensure<U, K extends PropertyKey> = K extends keyof U ? Require<U, K> : U & Record<K, unknown>;
+/**
+ * Type aware version of Object.prototype.hasOwnProperty.
+ * See https://fettblog.eu/typescript-hasownproperty/
+ */
+declare function hasOwnProperty<X extends {}, Y extends PropertyKey>(obj: X, prop: Y): obj is Ensure<X, Y>;
+/**
+ * Maps `obj` to a new object. The `mapper` function receives an entry array of key and value and
+ * is allowed to manipulate both. It can also return `null` to omit a property from the result.
+ */
+declare function mapProperties<P, L extends PropertyKey, U>(obj: P, mapper: <K extends PropertiesOf<P>>(old: [K, P[K]]) => [L, U] | null): Record<L, U>;
+/**
+ * Maps an objects' property keys. The result is a new object with the mapped keys, but the same values.
+ */
+declare function mapKeys<U>(obj: Record<string, U>, mapper: (old: string) => string): Record<string, U>;
+/**
+ * Maps an objects' property values. The result is a new object with the same keys, but mapped values.
+ */
+declare function mapValues<P, V>(obj: P, mapper: (old: P[PropertiesOf<P>], key: PropertiesOf<P>) => V): Record<PropertiesOf<P>, V>;
+/**
+ * Filters an objects' property values. Similar to `array.filter` but for objects. The result is a new
+ * object with all the properties removed for which `filter` returned `false`.
+ */
+declare function filterValues<K extends PropertyKey, P, Q extends P>(obj: Record<K, P>, filter: (old: P) => old is Q): Record<K, Q>;
+declare function filterValues<P>(obj: P, filter: (old: P[keyof P]) => boolean): Partial<P>;
+declare function filterValues<U>(obj: Record<string, U>, filter: (old: U) => boolean): Record<string, U>;
+/**
+ * Filters an objects' property keys. Similar to `array.filter` but for objects. The result is a new
+ * object with all the properties removed for which `filter` returned `false`.
+ */
+declare function filterKeys<P>(obj: P, filter: (old: keyof P) => boolean): Partial<P>;
+declare function filterKeys<U>(obj: Record<string, U>, filter: (old: string) => boolean): Record<string, U>;
+/**
+ * Compares the properties of two objects. Returns `true` if all properties are strictly equal, `false`
+ * otherwise.
+ * Pass a subset of properties to only compare those.
+ */
+declare function equalProperties<P extends object>(obj1: P, obj2: P, subset?: (keyof P)[]): boolean;
+
+/**
+ * Like `Array.prototype.join`, but for React nodes.
+ */
+declare function interleave(items: React.ReactNode[], separator: React.ReactNode): React.ReactNode;
+/**
+ * Consume a context but throw when used outside of a provider.
+ */
+declare function useNonNullableContext<T>(context: React.Context<T>, name?: string): NonNullable<T>;
+/**
+ * Context that throws when used outside of a provider.
+ */
+declare function createProvidedContext<T>(name?: string): [() => T, React.ComponentType<React.ProviderProps<T>>];
+declare function useAssertedContext<T>(context: React.Context<T | undefined>): T;
+/**
+ * Debugging tool that logs updates to props.
+ */
+declare function useTraceUpdates<P extends object>(prefix: string, props: P): void;
+/**
+ * Create a shared state to be used across the application. Returns a useState hook that
+ * is synchronized on the same state between all instances where it is called.
+ */
+declare function createGlobalState<T>(initialState: T): {
+    getState: () => T;
+    setState: (newState: T | ((oldValue: T) => T)) => void;
+    useValue: () => T;
+    useState: () => [T, React.Dispatch<React.SetStateAction<T>>];
+    subscribe: (cb: (state: T) => void) => () => void;
+};
+
+/**
+ * A utility with shortcuts to manipulate boolean values.
+ */
+declare function useBoolean(initialValue: boolean): {
+    value: boolean;
+    setValue: React.Dispatch<React.SetStateAction<boolean>>;
+    toggle: () => void;
+    setTrue: () => void;
+    setFalse: () => void;
+};
+
+/**
+ * Sets the current document title.
+ */
+declare function usePageTitle(title: string): void;
+
+/**
+ * Warns only once for a specific message.
+ * @param msg The message to warn.
+ */
+declare function warnOnce(msg: string): void;
+
+export { asArray, createGlobalState, createProvidedContext, equalProperties, filterKeys, filterValues, hasOwnProperty, interleave, mapKeys, mapProperties, mapValues, useAssertedContext, useBoolean, useNonNullableContext, usePageTitle, useTraceUpdates, warnOnce };

package/dist/utils.d.ts

@@ -0,0 +1,98 @@
+import * as React from 'react';
+
+declare function asArray<T>(maybeArray: T | T[]): T[];
+type PropertiesOf<P> = Extract<keyof P, string>;
+type Require<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+type Ensure<U, K extends PropertyKey> = K extends keyof U ? Require<U, K> : U & Record<K, unknown>;
+/**
+ * Type aware version of Object.prototype.hasOwnProperty.
+ * See https://fettblog.eu/typescript-hasownproperty/
+ */
+declare function hasOwnProperty<X extends {}, Y extends PropertyKey>(obj: X, prop: Y): obj is Ensure<X, Y>;
+/**
+ * Maps `obj` to a new object. The `mapper` function receives an entry array of key and value and
+ * is allowed to manipulate both. It can also return `null` to omit a property from the result.
+ */
+declare function mapProperties<P, L extends PropertyKey, U>(obj: P, mapper: <K extends PropertiesOf<P>>(old: [K, P[K]]) => [L, U] | null): Record<L, U>;
+/**
+ * Maps an objects' property keys. The result is a new object with the mapped keys, but the same values.
+ */
+declare function mapKeys<U>(obj: Record<string, U>, mapper: (old: string) => string): Record<string, U>;
+/**
+ * Maps an objects' property values. The result is a new object with the same keys, but mapped values.
+ */
+declare function mapValues<P, V>(obj: P, mapper: (old: P[PropertiesOf<P>], key: PropertiesOf<P>) => V): Record<PropertiesOf<P>, V>;
+/**
+ * Filters an objects' property values. Similar to `array.filter` but for objects. The result is a new
+ * object with all the properties removed for which `filter` returned `false`.
+ */
+declare function filterValues<K extends PropertyKey, P, Q extends P>(obj: Record<K, P>, filter: (old: P) => old is Q): Record<K, Q>;
+declare function filterValues<P>(obj: P, filter: (old: P[keyof P]) => boolean): Partial<P>;
+declare function filterValues<U>(obj: Record<string, U>, filter: (old: U) => boolean): Record<string, U>;
+/**
+ * Filters an objects' property keys. Similar to `array.filter` but for objects. The result is a new
+ * object with all the properties removed for which `filter` returned `false`.
+ */
+declare function filterKeys<P>(obj: P, filter: (old: keyof P) => boolean): Partial<P>;
+declare function filterKeys<U>(obj: Record<string, U>, filter: (old: string) => boolean): Record<string, U>;
+/**
+ * Compares the properties of two objects. Returns `true` if all properties are strictly equal, `false`
+ * otherwise.
+ * Pass a subset of properties to only compare those.
+ */
+declare function equalProperties<P extends object>(obj1: P, obj2: P, subset?: (keyof P)[]): boolean;
+
+/**
+ * Like `Array.prototype.join`, but for React nodes.
+ */
+declare function interleave(items: React.ReactNode[], separator: React.ReactNode): React.ReactNode;
+/**
+ * Consume a context but throw when used outside of a provider.
+ */
+declare function useNonNullableContext<T>(context: React.Context<T>, name?: string): NonNullable<T>;
+/**
+ * Context that throws when used outside of a provider.
+ */
+declare function createProvidedContext<T>(name?: string): [() => T, React.ComponentType<React.ProviderProps<T>>];
+declare function useAssertedContext<T>(context: React.Context<T | undefined>): T;
+/**
+ * Debugging tool that logs updates to props.
+ */
+declare function useTraceUpdates<P extends object>(prefix: string, props: P): void;
+/**
+ * Create a shared state to be used across the application. Returns a useState hook that
+ * is synchronized on the same state between all instances where it is called.
+ */
+declare function createGlobalState<T>(initialState: T): {
+    getState: () => T;
+    setState: (newState: T | ((oldValue: T) => T)) => void;
+    useValue: () => T;
+    useState: () => [T, React.Dispatch<React.SetStateAction<T>>];
+    subscribe: (cb: (state: T) => void) => () => void;
+};
+
+/**
+ * A utility with shortcuts to manipulate boolean values.
+ */
+declare function useBoolean(initialValue: boolean): {
+    value: boolean;
+    setValue: React.Dispatch<React.SetStateAction<boolean>>;
+    toggle: () => void;
+    setTrue: () => void;
+    setFalse: () => void;
+};
+
+/**
+ * Sets the current document title.
+ */
+declare function usePageTitle(title: string): void;
+
+/**
+ * Warns only once for a specific message.
+ * @param msg The message to warn.
+ */
+declare function warnOnce(msg: string): void;
+
+export { asArray, createGlobalState, createProvidedContext, equalProperties, filterKeys, filterValues, hasOwnProperty, interleave, mapKeys, mapProperties, mapValues, useAssertedContext, useBoolean, useNonNullableContext, usePageTitle, useTraceUpdates, warnOnce };

package/dist/utils.js

@@ -0,0 +1,218 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  asArray: () => asArray,
+  createGlobalState: () => createGlobalState,
+  createProvidedContext: () => createProvidedContext,
+  equalProperties: () => equalProperties,
+  filterKeys: () => filterKeys,
+  filterValues: () => filterValues,
+  hasOwnProperty: () => hasOwnProperty,
+  interleave: () => interleave,
+  mapKeys: () => mapKeys,
+  mapProperties: () => mapProperties,
+  mapValues: () => mapValues,
+  useAssertedContext: () => useAssertedContext,
+  useBoolean: () => useBoolean,
+  useNonNullableContext: () => useNonNullableContext,
+  usePageTitle: () => usePageTitle,
+  useTraceUpdates: () => useTraceUpdates,
+  warnOnce: () => warnOnce
+});
+module.exports = __toCommonJS(utils_exports);
+
+// src/toolpad-utils/collections.ts
+function asArray(maybeArray) {
+  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];
+}
+function hasOwnProperty(obj, prop) {
+  return obj.hasOwnProperty(prop);
+}
+function mapProperties(obj, mapper) {
+  return Object.fromEntries(
+    Object.entries(obj).flatMap((entry) => {
+      const mapped = mapper(entry);
+      return mapped ? [mapped] : [];
+    })
+  );
+}
+function mapKeys(obj, mapper) {
+  return mapProperties(obj, ([key, value]) => [mapper(key), value]);
+}
+function mapValues(obj, mapper) {
+  return mapProperties(obj, ([key, value]) => [key, mapper(value, key)]);
+}
+function filterValues(obj, filter) {
+  return mapProperties(obj, ([key, value]) => filter(value) ? [key, value] : null);
+}
+function filterKeys(obj, filter) {
+  return mapProperties(obj, ([key, value]) => filter(key) ? [key, value] : null);
+}
+function equalProperties(obj1, obj2, subset) {
+  const keysToCheck = new Set(
+    subset != null ? subset : [...Object.keys(obj1), ...Object.keys(obj2)]
+  );
+  return Array.from(keysToCheck).every((key) => Object.is(obj1[key], obj2[key]));
+}
+
+// src/toolpad-utils/react.tsx
+var React = __toESM(require("react"));
+var ReactIs = __toESM(require("react-is"));
+var import_jsx_runtime = require("react/jsx-runtime");
+function interleave(items, separator) {
+  const result = [];
+  for (let i = 0; i < items.length; i += 1) {
+    if (i > 0) {
+      if (ReactIs.isElement(separator)) {
+        result.push(React.cloneElement(separator, { key: `separator-${i}` }));
+      } else {
+        result.push(separator);
+      }
+    }
+    const item = items[i];
+    result.push(item);
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(React.Fragment, { children: result });
+}
+function useNonNullableContext(context, name) {
+  const maybeContext = React.useContext(context);
+  if (maybeContext === null || maybeContext === void 0) {
+    throw new Error(`context "${name}" was used without a Provider`);
+  }
+  return maybeContext;
+}
+function createProvidedContext(name) {
+  const context = React.createContext(void 0);
+  const useContext2 = () => useNonNullableContext(context, name);
+  return [useContext2, context.Provider];
+}
+function useAssertedContext(context) {
+  const value = React.useContext(context);
+  if (value === void 0) {
+    throw new Error("context was used without a Provider");
+  }
+  return value;
+}
+function useTraceUpdates(prefix, props) {
+  const prev = React.useRef(props);
+  React.useEffect(() => {
+    const changedProps = {};
+    for (const key of Object.keys(props)) {
+      if (!Object.is(prev.current[key], props[key])) {
+        changedProps[key] = props[key];
+      }
+    }
+    if (Object.keys(changedProps).length > 0) {
+      console.log(`${prefix} changed props:`, changedProps);
+    }
+    prev.current = props;
+  });
+}
+function createGlobalState(initialState) {
+  let state = initialState;
+  const listeners = [];
+  const subscribe = (cb) => {
+    listeners.push(cb);
+    return () => {
+      const index = listeners.indexOf(cb);
+      listeners.splice(index, 1);
+    };
+  };
+  const getState = () => state;
+  const setState = (newState) => {
+    state = typeof newState === "function" ? newState(state) : newState;
+    listeners.forEach((cb) => cb(state));
+  };
+  const useValue = () => React.useSyncExternalStore(subscribe, getState, getState);
+  const useState2 = () => {
+    const value = useValue();
+    return [value, setState];
+  };
+  return {
+    getState,
+    setState,
+    useValue,
+    useState: useState2,
+    subscribe
+  };
+}
+
+// src/toolpad-utils/hooks/useBoolean.ts
+var React2 = __toESM(require("react"));
+function useBoolean(initialValue) {
+  const [value, setValue] = React2.useState(initialValue);
+  const toggle = React2.useCallback(() => setValue((existing) => !existing), []);
+  const setTrue = React2.useCallback(() => setValue(true), []);
+  const setFalse = React2.useCallback(() => setValue(false), []);
+  return { value, setValue, toggle, setTrue, setFalse };
+}
+
+// src/toolpad-utils/hooks/usePageTitle.ts
+var React3 = __toESM(require("react"));
+function usePageTitle(title) {
+  React3.useEffect(() => {
+    const original = document.title;
+    document.title = title;
+    return () => {
+      document.title = original;
+    };
+  }, [title]);
+}
+
+// src/toolpad-utils/warnOnce.ts
+var history = /* @__PURE__ */ new Set();
+function warnOnce(msg) {
+  if (!history.has(msg)) {
+    history.add(msg);
+    console.warn(msg);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  asArray,
+  createGlobalState,
+  createProvidedContext,
+  equalProperties,
+  filterKeys,
+  filterValues,
+  hasOwnProperty,
+  interleave,
+  mapKeys,
+  mapProperties,
+  mapValues,
+  useAssertedContext,
+  useBoolean,
+  useNonNullableContext,
+  usePageTitle,
+  useTraceUpdates,
+  warnOnce
+});

package/dist/utils.mjs

@@ -0,0 +1,44 @@
+import {
+  useBoolean,
+  usePageTitle
+} from "./chunk-CENJI4RY.mjs";
+import {
+  warnOnce
+} from "./chunk-F6JD4MSY.mjs";
+import {
+  asArray,
+  equalProperties,
+  filterKeys,
+  filterValues,
+  hasOwnProperty,
+  mapKeys,
+  mapProperties,
+  mapValues
+} from "./chunk-UNVYOWC2.mjs";
+import {
+  createGlobalState,
+  createProvidedContext,
+  interleave,
+  useAssertedContext,
+  useNonNullableContext,
+  useTraceUpdates
+} from "./chunk-3JWXE2JW.mjs";
+export {
+  asArray,
+  createGlobalState,
+  createProvidedContext,
+  equalProperties,
+  filterKeys,
+  filterValues,
+  hasOwnProperty,
+  interleave,
+  mapKeys,
+  mapProperties,
+  mapValues,
+  useAssertedContext,
+  useBoolean,
+  useNonNullableContext,
+  usePageTitle,
+  useTraceUpdates,
+  warnOnce
+};

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@iowas/toolpad",
+  "version": "1.0.0",
+  "description": "Custom mui-toolpad",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./core": {
+      "types": "./dist/core.d.ts",
+      "import": "./dist/core.mjs",
+      "require": "./dist/core.js"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "import": "./dist/utils.mjs",
+      "require": "./dist/utils.js"
+    },
+    "./nextjs": {
+      "types": "./dist/nextjs.d.ts",
+      "import": "./dist/nextjs.mjs",
+      "require": "./dist/nextjs.js"
+    }
+  },
+  "dependencies": {
+    "invariant": "2.2.4",
+    "path-to-regexp": "8.4.1",
+    "prop-types": "15.8.1",
+    "react-is": "^19.2.4"
+  },
+  "peerDependencies": {
+    "@emotion/cache": "^11.14.0",
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.1",
+    "@mui/icons-material": "^7.3.9",
+    "@mui/material": "^7.3.9",
+    "@mui/material-nextjs": "^7.3.9",
+    "@mui/utils": "^7.3.9",
+    "next": "^16.2.2",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4"
+  },
+  "peerDependenciesMeta": {
+    "next": {
+      "optional": true
+    },
+    "@mui/material-nextjs": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.4",
+    "@types/invariant": "^2.2.37",
+    "@types/node": "^25.5.0",
+    "@types/prop-types": "^15.7.15",
+    "@types/react": "^19.2.14",
+    "@types/react-is": "^19.2.0",
+    "@types/react-dom": "^19.2.3",
+    "eslint": "^9.39.4",
+    "eslint-config-next": "^16.2.2",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "prettier": "3.8.1",
+    "pretty-quick": "^4.2.2",
+    "tsup": "^8.5.0",
+    "typescript": "^6.0.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [],
+  "author": "Peter Kudela",
+  "scripts": {
+    "build": "tsup src/index.ts src/core.ts src/utils.ts src/nextjs.ts --format esm,cjs --dts --clean --out-dir dist --tsconfig tsconfig.build.json",
+    "test": "echo \"No tests configured\""
+  }
+}