@rific/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jay Deaton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,147 @@
+# @rific/core
+
+Required foundation for `@rific/*` packages: a home for cross-cutting utilities every
+`@rific`-consuming app can use directly.
+
+- `createSettingsContext` — a generic Context/Provider/hook factory for a live, patchable settings
+  object whose persistence the consuming app owns.
+- `createSettingsSlice` — the same idea for Redux: a generic reducer + action-creator factory, with
+  zero dependency on `@reduxjs/toolkit` (or any Redux library at all).
+- `createModuleConfig` — a generic module-level config singleton, for injecting an optional peer
+  module (`react-native-paper`, `expo-camera`, etc.) without a hard dependency on it.
+
+## Why this exists
+
+`feedback-press` (sound + haptics), `scroll-view`, and `auto-paper`'s `ThemeProvider` each hand-roll
+the same ~30-line shape independently: a Context holding `{settings, set}`, a Provider taking
+`initialValue`/`onChange` so the app decides where (or whether) the setting is persisted, and an
+inert no-Provider-mounted default so nothing crashes if it's used without one. Each of those same
+three packages *also* independently hand-rolls an equivalent Redux slice — the exact same
+`createAction`/`.match()`/if-chain reducer, copy-pasted verbatim across all four files that need it
+(`hapticSlice.ts`, `soundSlice.ts`, `scrollViewSlice.ts`, `themeSlice.ts`). And `drawer`, `scanner`,
+and `resizable-input` each hand-roll the same module-level `let config` / `configureX` / `getXConfig`
+/ `XProvider` singleton for one-time optional-peer injection. `createSettingsContext`,
+`createSettingsSlice`, and `createModuleConfig` are each one of those shapes, written once.
+
+## `createSettingsContext` — Context-based settings
+
+```ts
+import { createSettingsContext } from '@rific/core'
+
+export type OrientationLockSettings = { locked: boolean }
+
+export const { Provider: OrientationLockProvider, useSettings: useOrientationLockSettings } =
+  createSettingsContext<OrientationLockSettings>({ locked: false })
+```
+
+```tsx
+// App root
+<OrientationLockProvider
+  initialValue={{ locked: persistedLockOrientation }}
+  onChange={(settings) => dispatch(gameActions.setLockOrientation(settings.locked))}
+>
+  <App />
+</OrientationLockProvider>
+```
+
+For the common case of a caller that only needs one field of the settings object as a plain
+`{value, setValue}` pair (mirrors `useOrientationLock`/`useSoundSettings`/`useHapticSettings`'s own
+shape), wrap the generated `useSettings` with `createSettingHook`:
+
+```ts
+import { createSettingHook } from '@rific/core'
+
+export const useOrientationLock = createSettingHook(useOrientationLockSettings, 'locked')
+// const { value: locked, setValue: setLocked } = useOrientationLock()
+```
+
+A settings object with several fields a caller patches together at once (e.g. sound + haptics) is
+better served calling the generated `useSettings()` directly and patching as needed, rather than one
+`createSettingHook` per field.
+
+## `createSettingsSlice` — Redux-based settings
+
+Same settings shape, for apps that persist through Redux instead of (or alongside) a Context. No
+dependency on `@reduxjs/toolkit`: works with RTK stores, vanilla Redux, or any reducer-based state
+container.
+
+```ts
+import { createSettingsSlice } from '@rific/core'
+
+export type HapticSettings = { vibrate: boolean }
+
+export const { actions: hapticActions, reducer: hapticReducer } = createSettingsSlice('haptic', {
+  initialState: { vibrate: true } as HapticSettings
+})
+// hapticActions.initialize({ vibrate: false }), hapticActions.setVibrate(false)
+```
+
+By default every field of `initialState` gets its own `setX` action (`setVibrate`, `setEnabled`,
+...) and `initialize` replaces the whole state wholesale — matching the fleet's most common shape.
+Three optional knobs cover the rest:
+
+```ts
+export const { actions: themeActions, reducer: themeReducer, createReducer: createThemeReducer, selectors } = createSettingsSlice('theme', {
+  initialState: { appearance: 'system', blur: true, color: '#6750a4', harmony: 'split-complementary' } as ThemeState,
+  initializeMode: 'merge',        // initialize(patch) merges instead of replacing
+  selectors: ['appearance', 'color'] // adds selectAppearance(state)/selectColor(state)
+})
+
+// createReducer lets a consumer override the default initial state at construction time —
+// independent of the runtime `initialize` action:
+const reducer = createThemeReducer({ color: DEFAULT_APP_COLOR })
+```
+
+To expose zero per-field setters (only `initialize`), pass `fieldSetters: []` — useful for a
+settings object an app only ever replaces wholesale, never patches one field at a time.
+
+## `createModuleConfig` — optional peer-module injection
+
+```ts
+import { createModuleConfig } from '@rific/core'
+import type { OptionalModule } from '@rific/core'
+
+export type MyPackageConfig = {
+  paper?: OptionalModule<PaperModuleShape>
+}
+
+export const { configure: configureMyPackage, getConfig: getMyPackageConfig, Provider: MyPackageProvider } =
+  createModuleConfig<MyPackageConfig>()
+```
+
+```tsx
+// App root — either call configure directly, or mount the generated Provider:
+<MyPackageProvider paper={RNPaper}>
+  <App />
+</MyPackageProvider>
+```
+
+Plain module-level state, not React Context — this is one-time app setup ("does this app have
+`react-native-paper`?"), not per-render reactive state, so calling `configure` again after
+components have already rendered won't retroactively update them. Fine for startup config, not for
+runtime toggling.
+
+## `OptionalModule<T>`
+
+Names the convention several packages already follow for the `paper`/`camera`/`autoPaper`-style
+props above: mirror only the small slice of the injected module's shape you actually use as a local
+type (never `typeof import('the-real-package')`, which still forces the type-checker to resolve the
+real module), accept it as an explicit prop rather than auto-detecting it (Metro doesn't rewrite a
+`require()`-in-`try/catch` call into its module graph inside an ESM build, so auto-detection breaks
+silently), and degrade gracefully when it's omitted. `OptionalModule<T>` is just `T | undefined` —
+its only value is giving that convention one name to point back to instead of re-deriving the
+reasoning fresh in every package's own doc comment.
+
+## Install
+
+```bash
+npm install @rific/core
+```
+
+## Peer Dependencies
+
+- `react` (>=19.0.0)
+- `react-native` (>=0.76.0) — not imported by anything in this package yet (every export here is
+  plain `react`), but declared up front to match every other `@rific`/`@tastic` foundation package,
+  since this is meant to grow into a home for other cross-cutting utilities the same way
+  `@tastic/core` did.

package/dist/index.d.mts

@@ -0,0 +1,74 @@
+import { ReactNode } from 'react';
+
+type ModuleConfigProviderProps<T> = T & {
+    children: ReactNode;
+};
+type ModuleConfigResult<T extends object> = {
+    configure: (next: Partial<T>) => void;
+    getConfig: () => T;
+    Provider: (props: ModuleConfigProviderProps<T>) => React.JSX.Element;
+};
+declare function createModuleConfig<T extends object>(defaults?: T): ModuleConfigResult<T>;
+
+type SettingsContextValue<T> = {
+    settings: T;
+    set: (patch: Partial<T>) => void;
+};
+type SettingsProviderProps<T> = {
+    children: ReactNode;
+    initialValue?: Partial<T>;
+    onChange?: (settings: T) => void;
+};
+type SettingsContextResult<T> = {
+    Context: React.Context<SettingsContextValue<T>>;
+    Provider: (props: SettingsProviderProps<T>) => React.JSX.Element;
+    useSettings: () => SettingsContextValue<T>;
+};
+declare function createSettingsContext<T extends object>(defaults: T): SettingsContextResult<T>;
+declare function createSettingHook<T extends object, K extends keyof T>(useSettings: () => SettingsContextValue<T>, key: K): () => {
+    value: T[K];
+    setValue: (value: T[K]) => void;
+};
+
+type SettingsAction<P> = {
+    payload: P;
+    type: string;
+};
+type ActionCreator<P> = {
+    (payload: P): SettingsAction<P>;
+    type: string;
+    match: (action: {
+        type: string;
+    }) => action is SettingsAction<P>;
+};
+type Capitalized<K extends PropertyKey> = K extends string ? Capitalize<K> : never;
+type FieldSetterActions<T, Fields extends keyof T> = {
+    [K in Fields as `set${Capitalized<K>}`]: ActionCreator<T[K]>;
+};
+type FieldSelectors<T, Fields extends keyof T> = {
+    [K in Fields as `select${Capitalized<K>}`]: (state: T) => T[K];
+};
+type SettingsReducer<T> = (state: T | undefined, action: {
+    type: string;
+}) => T;
+type InitializeMode = 'replace' | 'merge';
+type InitializePayload<T, Mode extends InitializeMode> = Mode extends 'merge' ? Partial<T> : T;
+type CreateSettingsSliceOptions<T extends object, Mode extends InitializeMode, SetterFields extends keyof T, SelectorFields extends keyof T> = {
+    initialState: T;
+    initializeMode?: Mode;
+    fieldSetters?: SetterFields[];
+    selectors?: SelectorFields[];
+};
+type SettingsSliceResult<T extends object, Mode extends InitializeMode, SetterFields extends keyof T, SelectorFields extends keyof T> = {
+    actions: {
+        initialize: ActionCreator<InitializePayload<T, Mode>>;
+    } & FieldSetterActions<T, SetterFields>;
+    reducer: SettingsReducer<T>;
+    createReducer: (overrideInitialState?: Partial<T>) => SettingsReducer<T>;
+    selectors: FieldSelectors<T, SelectorFields>;
+};
+declare function createSettingsSlice<T extends object, Mode extends InitializeMode = 'replace', SetterFields extends keyof T = keyof T, SelectorFields extends keyof T = never>(namespace: string, options: CreateSettingsSliceOptions<T, Mode, SetterFields, SelectorFields>): SettingsSliceResult<T, Mode, SetterFields, SelectorFields>;
+
+type OptionalModule<T> = T | undefined;
+
+export { type CreateSettingsSliceOptions, type InitializeMode, type ModuleConfigProviderProps, type ModuleConfigResult, type OptionalModule, type SettingsAction, type SettingsContextResult, type SettingsContextValue, type SettingsProviderProps, type SettingsReducer, type SettingsSliceResult, createModuleConfig, createSettingHook, createSettingsContext, createSettingsSlice };

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+import { ReactNode } from 'react';
+
+type ModuleConfigProviderProps<T> = T & {
+    children: ReactNode;
+};
+type ModuleConfigResult<T extends object> = {
+    configure: (next: Partial<T>) => void;
+    getConfig: () => T;
+    Provider: (props: ModuleConfigProviderProps<T>) => React.JSX.Element;
+};
+declare function createModuleConfig<T extends object>(defaults?: T): ModuleConfigResult<T>;
+
+type SettingsContextValue<T> = {
+    settings: T;
+    set: (patch: Partial<T>) => void;
+};
+type SettingsProviderProps<T> = {
+    children: ReactNode;
+    initialValue?: Partial<T>;
+    onChange?: (settings: T) => void;
+};
+type SettingsContextResult<T> = {
+    Context: React.Context<SettingsContextValue<T>>;
+    Provider: (props: SettingsProviderProps<T>) => React.JSX.Element;
+    useSettings: () => SettingsContextValue<T>;
+};
+declare function createSettingsContext<T extends object>(defaults: T): SettingsContextResult<T>;
+declare function createSettingHook<T extends object, K extends keyof T>(useSettings: () => SettingsContextValue<T>, key: K): () => {
+    value: T[K];
+    setValue: (value: T[K]) => void;
+};
+
+type SettingsAction<P> = {
+    payload: P;
+    type: string;
+};
+type ActionCreator<P> = {
+    (payload: P): SettingsAction<P>;
+    type: string;
+    match: (action: {
+        type: string;
+    }) => action is SettingsAction<P>;
+};
+type Capitalized<K extends PropertyKey> = K extends string ? Capitalize<K> : never;
+type FieldSetterActions<T, Fields extends keyof T> = {
+    [K in Fields as `set${Capitalized<K>}`]: ActionCreator<T[K]>;
+};
+type FieldSelectors<T, Fields extends keyof T> = {
+    [K in Fields as `select${Capitalized<K>}`]: (state: T) => T[K];
+};
+type SettingsReducer<T> = (state: T | undefined, action: {
+    type: string;
+}) => T;
+type InitializeMode = 'replace' | 'merge';
+type InitializePayload<T, Mode extends InitializeMode> = Mode extends 'merge' ? Partial<T> : T;
+type CreateSettingsSliceOptions<T extends object, Mode extends InitializeMode, SetterFields extends keyof T, SelectorFields extends keyof T> = {
+    initialState: T;
+    initializeMode?: Mode;
+    fieldSetters?: SetterFields[];
+    selectors?: SelectorFields[];
+};
+type SettingsSliceResult<T extends object, Mode extends InitializeMode, SetterFields extends keyof T, SelectorFields extends keyof T> = {
+    actions: {
+        initialize: ActionCreator<InitializePayload<T, Mode>>;
+    } & FieldSetterActions<T, SetterFields>;
+    reducer: SettingsReducer<T>;
+    createReducer: (overrideInitialState?: Partial<T>) => SettingsReducer<T>;
+    selectors: FieldSelectors<T, SelectorFields>;
+};
+declare function createSettingsSlice<T extends object, Mode extends InitializeMode = 'replace', SetterFields extends keyof T = keyof T, SelectorFields extends keyof T = never>(namespace: string, options: CreateSettingsSliceOptions<T, Mode, SetterFields, SelectorFields>): SettingsSliceResult<T, Mode, SetterFields, SelectorFields>;
+
+type OptionalModule<T> = T | undefined;
+
+export { type CreateSettingsSliceOptions, type InitializeMode, type ModuleConfigProviderProps, type ModuleConfigResult, type OptionalModule, type SettingsAction, type SettingsContextResult, type SettingsContextValue, type SettingsProviderProps, type SettingsReducer, type SettingsSliceResult, createModuleConfig, createSettingHook, createSettingsContext, createSettingsSlice };

package/dist/index.js

@@ -0,0 +1,122 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createModuleConfig: () => createModuleConfig,
+  createSettingHook: () => createSettingHook,
+  createSettingsContext: () => createSettingsContext,
+  createSettingsSlice: () => createSettingsSlice
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/createModuleConfig.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function createModuleConfig(defaults = {}) {
+  let config = defaults;
+  const configure = (next) => {
+    config = { ...config, ...next };
+  };
+  const getConfig = () => config;
+  function Provider({ children, ...rest }) {
+    configure(rest);
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children });
+  }
+  return { configure, getConfig, Provider };
+}
+
+// src/createSettingsContext.tsx
+var import_react = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function createSettingsContext(defaults) {
+  const Context = (0, import_react.createContext)({ settings: defaults, set: () => {
+  } });
+  function Provider({ children, initialValue, onChange }) {
+    const [settings, setSettings] = (0, import_react.useState)(() => ({ ...defaults, ...initialValue }));
+    const onChangeRef = (0, import_react.useRef)(onChange);
+    onChangeRef.current = onChange;
+    const set = (0, import_react.useCallback)((patch) => {
+      setSettings((prev) => {
+        const next = { ...prev, ...patch };
+        onChangeRef.current?.(next);
+        return next;
+      });
+    }, []);
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Context.Provider, { value: { settings, set }, children });
+  }
+  function useSettings() {
+    return (0, import_react.useContext)(Context);
+  }
+  return { Context, Provider, useSettings };
+}
+function createSettingHook(useSettings, key) {
+  return function useSetting() {
+    const { settings, set } = useSettings();
+    const setValue = (0, import_react.useCallback)((value) => set({ [key]: value }), [set]);
+    return { value: settings[key], setValue };
+  };
+}
+
+// src/createSettingsSlice.ts
+function capitalize(key) {
+  const s = String(key);
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function createActionCreator(type) {
+  const actionCreator = ((payload) => ({ payload, type }));
+  actionCreator.type = type;
+  actionCreator.match = (action) => action.type === type;
+  return actionCreator;
+}
+function createSettingsSlice(namespace, options) {
+  const { initialState, selectors = [] } = options;
+  const initializeMode = options.initializeMode ?? "replace";
+  const fieldSetters = options.fieldSetters ?? Object.keys(initialState);
+  const initialize = createActionCreator(`${namespace}/initialize`);
+  const setterEntries = fieldSetters.map((field) => {
+    const actionName = `set${capitalize(field)}`;
+    const creator = createActionCreator(`${namespace}/${actionName}`);
+    return { actionName, field, creator };
+  });
+  const actions = {
+    initialize,
+    ...Object.fromEntries(setterEntries.map(({ actionName, creator }) => [actionName, creator]))
+  };
+  const reduce = (state, action) => {
+    if (initialize.match(action)) return initializeMode === "merge" ? { ...state, ...action.payload } : action.payload;
+    for (const { field, creator } of setterEntries) {
+      if (creator.match(action)) return { ...state, [field]: action.payload };
+    }
+    return state;
+  };
+  function createReducer(overrideInitialState) {
+    const initial = { ...initialState, ...overrideInitialState };
+    return (state = initial, action) => reduce(state, action);
+  }
+  const selectorsObj = Object.fromEntries(selectors.map((field) => [`select${capitalize(field)}`, (state) => state[field]]));
+  return { actions, reducer: createReducer(), createReducer, selectors: selectorsObj };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createModuleConfig,
+  createSettingHook,
+  createSettingsContext,
+  createSettingsSlice
+});

package/dist/index.mjs

@@ -0,0 +1,92 @@
+// src/createModuleConfig.tsx
+import { Fragment, jsx } from "react/jsx-runtime";
+function createModuleConfig(defaults = {}) {
+  let config = defaults;
+  const configure = (next) => {
+    config = { ...config, ...next };
+  };
+  const getConfig = () => config;
+  function Provider({ children, ...rest }) {
+    configure(rest);
+    return /* @__PURE__ */ jsx(Fragment, { children });
+  }
+  return { configure, getConfig, Provider };
+}
+
+// src/createSettingsContext.tsx
+import { createContext, useCallback, useContext, useRef, useState } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function createSettingsContext(defaults) {
+  const Context = createContext({ settings: defaults, set: () => {
+  } });
+  function Provider({ children, initialValue, onChange }) {
+    const [settings, setSettings] = useState(() => ({ ...defaults, ...initialValue }));
+    const onChangeRef = useRef(onChange);
+    onChangeRef.current = onChange;
+    const set = useCallback((patch) => {
+      setSettings((prev) => {
+        const next = { ...prev, ...patch };
+        onChangeRef.current?.(next);
+        return next;
+      });
+    }, []);
+    return /* @__PURE__ */ jsx2(Context.Provider, { value: { settings, set }, children });
+  }
+  function useSettings() {
+    return useContext(Context);
+  }
+  return { Context, Provider, useSettings };
+}
+function createSettingHook(useSettings, key) {
+  return function useSetting() {
+    const { settings, set } = useSettings();
+    const setValue = useCallback((value) => set({ [key]: value }), [set]);
+    return { value: settings[key], setValue };
+  };
+}
+
+// src/createSettingsSlice.ts
+function capitalize(key) {
+  const s = String(key);
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function createActionCreator(type) {
+  const actionCreator = ((payload) => ({ payload, type }));
+  actionCreator.type = type;
+  actionCreator.match = (action) => action.type === type;
+  return actionCreator;
+}
+function createSettingsSlice(namespace, options) {
+  const { initialState, selectors = [] } = options;
+  const initializeMode = options.initializeMode ?? "replace";
+  const fieldSetters = options.fieldSetters ?? Object.keys(initialState);
+  const initialize = createActionCreator(`${namespace}/initialize`);
+  const setterEntries = fieldSetters.map((field) => {
+    const actionName = `set${capitalize(field)}`;
+    const creator = createActionCreator(`${namespace}/${actionName}`);
+    return { actionName, field, creator };
+  });
+  const actions = {
+    initialize,
+    ...Object.fromEntries(setterEntries.map(({ actionName, creator }) => [actionName, creator]))
+  };
+  const reduce = (state, action) => {
+    if (initialize.match(action)) return initializeMode === "merge" ? { ...state, ...action.payload } : action.payload;
+    for (const { field, creator } of setterEntries) {
+      if (creator.match(action)) return { ...state, [field]: action.payload };
+    }
+    return state;
+  };
+  function createReducer(overrideInitialState) {
+    const initial = { ...initialState, ...overrideInitialState };
+    return (state = initial, action) => reduce(state, action);
+  }
+  const selectorsObj = Object.fromEntries(selectors.map((field) => [`select${capitalize(field)}`, (state) => state[field]]));
+  return { actions, reducer: createReducer(), createReducer, selectors: selectorsObj };
+}
+export {
+  createModuleConfig,
+  createSettingHook,
+  createSettingsContext,
+  createSettingsSlice
+};

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@rific/core",
+  "version": "0.1.0",
+  "description": "Required foundation for @rific/* packages: createSettingsContext + createSettingsSlice for a live, patchable settings object (Context and Redux, respectively), and createModuleConfig for one-time optional-peer-module injection",
+  "keywords": [
+    "react-native",
+    "react",
+    "settings",
+    "context",
+    "provider",
+    "state",
+    "redux"
+  ],
+  "homepage": "https://github.com/jayrdeaton/react-native-core#readme",
+  "bugs": {
+    "url": "https://github.com/jayrdeaton/react-native-core/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jayrdeaton/react-native-core.git"
+  },
+  "license": "MIT",
+  "author": "Jay Deaton",
+  "sideEffects": false,
+  "type": "commonjs",
+  "exports": {
+    ".": {
+      "react-native": "./src/index.ts",
+      "browser": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "react-native": "src/index.ts",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "!src/__tests__",
+    "!src/__mocks__"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "build:watch": "tsup --watch",
+    "fix": "eslint --fix",
+    "lint": "eslint",
+    "prepublishOnly": "npm run build",
+    "release": "git push --follow-tags",
+    "release:major": "npm version major && npm run release",
+    "release:minor": "npm version minor && npm run release",
+    "release:patch": "npm version patch && npm run release",
+    "test": "jest",
+    "test:watch": "jest --watchAll",
+    "typecheck": "tsc --noEmit",
+    "verify": "npm run lint && npm test && npm run typecheck && npm run build",
+    "preversion": "npm run verify"
+  },
+  "prettier": "@infinitetoken/eslint-config/prettier",
+  "devDependencies": {
+    "@infinitetoken/eslint-config": "^0.2.0",
+    "@infinitetoken/jest-config": "^0.3.0",
+    "@infinitetoken/tsconfig": "^0.4.1",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/jest": "^30.0.0",
+    "@types/react": "^19.0.0",
+    "eslint": "^9.39.4",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "eslint-plugin-react-native": "^5.0.0",
+    "jest": "^30.4.2",
+    "jest-environment-jsdom": "^30.4.1",
+    "prettier": "^3.8.3",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-native": "^0.85.3",
+    "tsup": "^8.0.0",
+    "typescript": "^6.0.3"
+  },
+  "peerDependencies": {
+    "react": ">=19.0.0",
+    "react-native": ">=0.76.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/OptionalModule.ts

@@ -0,0 +1,19 @@
+// Names the convention feedback-press, drawer, scanner, and auto-paper each already follow (and
+// each re-explain from scratch in their own doc comments) for injecting an optional peer module
+// (react-native-paper, expo-camera, expo-blur, react-native-reanimated, etc.) without a hard
+// dependency on it:
+//
+// 1. Auto-detection via a require()-in-try/catch call doesn't work reliably: Metro doesn't rewrite
+//    that call into its module graph inside an ESM (.mjs) build, so module-level auto-detection
+//    silently breaks the moment a consumer's bundler resolves the package's ESM entry point.
+// 2. So instead, accept the module as an explicit injected prop (e.g. `paper?: OptionalModule<PaperModuleShape>`)
+//    and have the consuming app pass `import * as RNPaper from 'react-native-paper'` itself.
+// 3. Mirror only the small slice of the module's shape you actually use as a local type — never
+//    `typeof import('the-real-package')`, which still forces the type-checker to resolve the real
+//    module and defeats the point of not hard-depending on it.
+// 4. Degrade gracefully when the prop is omitted (a plain fallback UI, a no-op), never throw.
+//
+// This type is deliberately trivial (`T | undefined`) — its value is giving that convention one
+// name every package's own doc comment can point back to, instead of re-deriving the same
+// reasoning independently each time a new optional peer gets injected.
+export type OptionalModule<T> = T | undefined

package/src/createModuleConfig.tsx

@@ -0,0 +1,42 @@
+import type { ReactNode } from 'react'
+
+// Generalizes the module-level config-singleton shape duplicated identically across
+// @rific/drawer's DrawerConfig.tsx, @rific/scanner's ScannerConfig.tsx, and
+// @rific/resizable-input's ResizableInputConfig.tsx — each hand-rolls the same five pieces
+// (a module-level `let config`, `configureX`/`getXConfig`, an `XProviderProps` type, and an
+// `XProvider` that just calls `configureX` synchronously during render) to inject optional peer
+// modules (react-native-paper, expo-camera, etc.) without a hard dependency on them. Plain
+// module-level state rather than React Context, deliberately: this is one-time app setup ("does
+// this app have react-native-paper?"), not per-render reactive state — see each real package's own
+// comment on why a Provider-only API would be more ceremony than the problem needs. Not reactive:
+// calling `configure` again after components have already rendered won't retroactively update
+// them, which is fine for startup config, not for runtime toggling.
+
+export type ModuleConfigProviderProps<T> = T & { children: ReactNode }
+
+export type ModuleConfigResult<T extends object> = {
+  configure: (next: Partial<T>) => void
+  getConfig: () => T
+  // Thin wrapper around `configure` for consumers who'd rather mount a Provider than call the
+  // setup function directly. Calls `configure` synchronously during render (not in an effect), so
+  // the config is already set by the time any descendant component renders — effects run
+  // bottom-up after children have already rendered once, which would be one render too late here.
+  Provider: (props: ModuleConfigProviderProps<T>) => React.JSX.Element
+}
+
+export function createModuleConfig<T extends object>(defaults: T = {} as T): ModuleConfigResult<T> {
+  let config: T = defaults
+
+  const configure = (next: Partial<T>) => {
+    config = { ...config, ...next }
+  }
+
+  const getConfig = (): T => config
+
+  function Provider({ children, ...rest }: ModuleConfigProviderProps<T>) {
+    configure(rest as Partial<T>)
+    return <>{children}</>
+  }
+
+  return { configure, getConfig, Provider }
+}

package/src/createSettingsContext.tsx

@@ -0,0 +1,75 @@
+import { createContext, type ReactNode, useCallback, useContext, useRef, useState } from 'react'
+
+export type SettingsContextValue<T> = {
+  settings: T
+  set: (patch: Partial<T>) => void
+}
+
+export type SettingsProviderProps<T> = {
+  children: ReactNode
+  // Rehydrates from the consuming app's own storage at mount time — this factory (like every
+  // hand-rolled settings Provider it replaces) deliberately does no persistence of its own. The app
+  // decides where, or whether, `settings` gets saved.
+  initialValue?: Partial<T>
+  // Fires with the full settings object on every `set` call — the app's hook into persisting it.
+  onChange?: (settings: T) => void
+}
+
+export type SettingsContextResult<T> = {
+  Context: React.Context<SettingsContextValue<T>>
+  Provider: (props: SettingsProviderProps<T>) => React.JSX.Element
+  useSettings: () => SettingsContextValue<T>
+}
+
+// Builds one {Context, Provider, useSettings} triple for a single settings shape T. Matches the
+// initialValue/onChange/patch-based contract already duplicated by hand, near-identically, across
+// this fleet's own settings Providers (feedback-press's sound + haptics, scroll-view's own settings,
+// auto-paper's ThemeProvider, @tastic/core's orientation-lock context) — every one of those is this
+// same ~30-line shape typed out separately. `defaults` seeds both the Context's own inert
+// no-Provider-mounted fallback (settings read as `defaults`, `set` silently drops — the same
+// "nothing crashes, it just never resolves" degradation every one of those packages already
+// documents for a missing Provider) and the Provider's real initial state, patched by `initialValue`.
+export function createSettingsContext<T extends object>(defaults: T): SettingsContextResult<T> {
+  const Context = createContext<SettingsContextValue<T>>({ settings: defaults, set: () => {} })
+
+  function Provider({ children, initialValue, onChange }: SettingsProviderProps<T>) {
+    const [settings, setSettings] = useState<T>(() => ({ ...defaults, ...initialValue }))
+
+    // Read via a ref rather than closed over directly, so `set`'s identity never changes just
+    // because the caller passed a fresh `onChange` closure this render — a consumer that memoizes
+    // off `set`'s stability (or hands it deep into a tree) doesn't re-render every time the app's
+    // own onChange callback is redefined.
+    const onChangeRef = useRef(onChange)
+    onChangeRef.current = onChange
+
+    const set = useCallback((patch: Partial<T>) => {
+      setSettings((prev) => {
+        const next = { ...prev, ...patch }
+        onChangeRef.current?.(next)
+        return next
+      })
+    }, [])
+
+    return <Context.Provider value={{ settings, set }}>{children}</Context.Provider>
+  }
+
+  function useSettings(): SettingsContextValue<T> {
+    return useContext(Context)
+  }
+
+  return { Context, Provider, useSettings }
+}
+
+// Thin convenience for the common single-field case — the {value, setValue} shape this fleet's own
+// useOrientationLock/useSoundSettings/useHapticSettings hooks each hand-roll individually, for a
+// caller that only cares about one field of a larger settings object rather than the whole
+// patch-based contract. Not every consumer needs this — one juggling several fields at once (e.g.
+// feedback-press's own sound/haptic sub-settings) is still better served calling useSettings()
+// directly and patching as needed.
+export function createSettingHook<T extends object, K extends keyof T>(useSettings: () => SettingsContextValue<T>, key: K) {
+  return function useSetting(): { value: T[K]; setValue: (value: T[K]) => void } {
+    const { settings, set } = useSettings()
+    const setValue = useCallback((value: T[K]) => set({ [key]: value } as unknown as Partial<T>), [set])
+    return { value: settings[key], setValue }
+  }
+}

package/src/createSettingsSlice.ts

@@ -0,0 +1,113 @@
+// Generalizes the Redux slice half of the same duplicated shape createSettingsContext already
+// covers for the Context half. feedback-press's hapticSlice.ts/soundSlice.ts, scroll-view's
+// scrollViewSlice.ts, and auto-paper's themeSlice.ts each hand-roll an identical createAction/
+// .match()/if-chain reducer — the exact block below is copy-pasted verbatim across all four today.
+// This factory reproduces every real behavior those four files need (including auto-paper's own
+// wrinkles: a merging `initialize`, an overridable reducer factory, and per-field selectors) as
+// plain config, not new logic.
+
+export type SettingsAction<P> = { payload: P; type: string }
+
+type ActionCreator<P> = {
+  (payload: P): SettingsAction<P>
+  type: string
+  match: (action: { type: string }) => action is SettingsAction<P>
+}
+
+type Capitalized<K extends PropertyKey> = K extends string ? Capitalize<K> : never
+
+type FieldSetterActions<T, Fields extends keyof T> = {
+  [K in Fields as `set${Capitalized<K>}`]: ActionCreator<T[K]>
+}
+
+type FieldSelectors<T, Fields extends keyof T> = {
+  [K in Fields as `select${Capitalized<K>}`]: (state: T) => T[K]
+}
+
+export type SettingsReducer<T> = (state: T | undefined, action: { type: string }) => T
+
+// 'replace' (the default, and what haptic/sound/scrollView all do): `initialize`'s payload becomes
+// the entire next state, verbatim — matches how every real call site already dispatches it (the
+// app's own onChange handler always hands back a complete settings object, never a partial one),
+// so `initialize` takes the full T. 'merge' (only auto-paper's theme needs this): the payload is
+// spread over the existing state instead, so `initialize` takes a Partial<T> — a caller can seed
+// just part of it.
+export type InitializeMode = 'replace' | 'merge'
+
+type InitializePayload<T, Mode extends InitializeMode> = Mode extends 'merge' ? Partial<T> : T
+
+export type CreateSettingsSliceOptions<T extends object, Mode extends InitializeMode, SetterFields extends keyof T, SelectorFields extends keyof T> = {
+  initialState: T
+  initializeMode?: Mode
+  // Which fields get a dedicated setX action (e.g. `vibrate` -> `setVibrate`). Defaults to every key
+  // of initialState — matches haptic/sound/theme, which each expose one setter per field.
+  // scrollView needs this passed as `[]` explicitly: it has 6 fields but zero per-field setters,
+  // relying on `initialize` alone.
+  fieldSetters?: SetterFields[]
+  // Which fields get a generated selectX(state) => state[field]. Defaults to none — only auto-paper's
+  // theme slice has these today.
+  selectors?: SelectorFields[]
+}
+
+export type SettingsSliceResult<T extends object, Mode extends InitializeMode, SetterFields extends keyof T, SelectorFields extends keyof T> = {
+  actions: { initialize: ActionCreator<InitializePayload<T, Mode>> } & FieldSetterActions<T, SetterFields>
+  reducer: SettingsReducer<T>
+  // The auto-paper wrinkle: a factory that lets a consumer override the default initial state at
+  // construction time (e.g. seeding a per-app default color), independent of the runtime `initialize`
+  // action. `reducer` above is just `createReducer()` with no override.
+  createReducer: (overrideInitialState?: Partial<T>) => SettingsReducer<T>
+  selectors: FieldSelectors<T, SelectorFields>
+}
+
+function capitalize<K extends PropertyKey>(key: K): Capitalized<K> {
+  const s = String(key)
+  return (s.charAt(0).toUpperCase() + s.slice(1)) as Capitalized<K>
+}
+
+function createActionCreator<P>(type: string): ActionCreator<P> {
+  const actionCreator = ((payload: P) => ({ payload, type })) as ActionCreator<P>
+  actionCreator.type = type
+  actionCreator.match = (action: { type: string }): action is SettingsAction<P> => action.type === type
+  return actionCreator
+}
+
+// `namespace` prefixes every action type (e.g. 'haptic/initialize', 'theme/setAppearance') so
+// multiple slices combined in one store never collide — matches the fleet's existing convention
+// exactly (hapticSlice's own action types are literally 'haptic/initialize' etc. today).
+export function createSettingsSlice<T extends object, Mode extends InitializeMode = 'replace', SetterFields extends keyof T = keyof T, SelectorFields extends keyof T = never>(namespace: string, options: CreateSettingsSliceOptions<T, Mode, SetterFields, SelectorFields>): SettingsSliceResult<T, Mode, SetterFields, SelectorFields> {
+  const { initialState, selectors = [] } = options
+  const initializeMode: InitializeMode = options.initializeMode ?? 'replace'
+  const fieldSetters = options.fieldSetters ?? (Object.keys(initialState) as SetterFields[])
+
+  // Internally untyped (any payload) — the precise conditional typing based on `Mode` lives only
+  // in the exported return type below; the runtime logic itself doesn't need to know Mode at the
+  // type level, only the `initializeMode` string value it already has.
+  const initialize = createActionCreator<Partial<T> | T>(`${namespace}/initialize`)
+  const setterEntries = fieldSetters.map((field) => {
+    const actionName = `set${capitalize(field)}`
+    const creator = createActionCreator<T[typeof field]>(`${namespace}/${actionName}`)
+    return { actionName, field, creator }
+  })
+
+  const actions = {
+    initialize,
+    ...Object.fromEntries(setterEntries.map(({ actionName, creator }) => [actionName, creator]))
+  } as unknown as SettingsSliceResult<T, Mode, SetterFields, SelectorFields>['actions']
+
+  const reduce = (state: T, action: { type: string }): T => {
+    if (initialize.match(action)) return initializeMode === 'merge' ? { ...state, ...(action.payload as Partial<T>) } : (action.payload as T)
+    for (const { field, creator } of setterEntries) {
+      if (creator.match(action)) return { ...state, [field]: action.payload }
+    }
+    return state
+  }
+
+  function createReducer(overrideInitialState?: Partial<T>): SettingsReducer<T> {
+    const initial = { ...initialState, ...overrideInitialState }
+    return (state: T = initial, action: { type: string }): T => reduce(state, action)
+  }
+
+  const selectorsObj = Object.fromEntries(selectors.map((field) => [`select${capitalize(field)}`, (state: T) => state[field]])) as unknown as SettingsSliceResult<T, Mode, SetterFields, SelectorFields>['selectors']
+
+  return { actions, reducer: createReducer(), createReducer, selectors: selectorsObj }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export type { ModuleConfigProviderProps, ModuleConfigResult } from './createModuleConfig'
+export { createModuleConfig } from './createModuleConfig'
+export type { SettingsContextResult, SettingsContextValue, SettingsProviderProps } from './createSettingsContext'
+export { createSettingHook, createSettingsContext } from './createSettingsContext'
+export type { CreateSettingsSliceOptions, InitializeMode, SettingsAction, SettingsReducer, SettingsSliceResult } from './createSettingsSlice'
+export { createSettingsSlice } from './createSettingsSlice'
+export type { OptionalModule } from './OptionalModule'