rei-kit 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ramazan Doğan
+
+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,87 @@
+# rei-kit
+
+Vue 3 and Tailwind 4 design system and shared runtime. Extracted from
+[Hibi](https://github.com/ramazandogna/hibi).
+
+零 — the layer everything else starts from.
+
+## Why it exists
+
+Hibi's shared layer turned out to be genuinely portable: no file under
+`shared/` imported from `features/`, so the components, the date and theme
+helpers, and the i18n runtime could leave without being rewritten. This is that
+layer, packaged so the next app installs it instead of copying it.
+
+## Status
+
+**v0.0.0 — extraction complete, no consumer yet.** Thirteen components,
+eight utilities, six composables, a generic i18n runtime and an optional
+Supabase entry. Hibi moves onto it next.
+
+## Install
+
+```sh
+pnpm add rei-kit
+```
+
+`vue`, `tailwindcss` and `lucide-vue-next` are peer dependencies — the app
+supplies them, so there is never a second copy of the Vue runtime.
+`vue-i18n` is optional and only needed for the i18n runtime.
+
+## Use
+
+```vue
+<script setup lang="ts">
+import { BaseButton, BaseSheet, useTheme } from 'rei-kit'
+
+const theme = useTheme()
+</script>
+```
+
+Supabase lives behind its own entry, so an app that does not use it never
+downloads it:
+
+```ts
+import { createSupabaseClient } from 'rei-kit/supabase'
+```
+
+```css
+/* your app's main.css */
+@import 'tailwindcss';
+@import 'rei-kit/tokens.css'; /* Tailwind source: tokens and utilities */
+@import 'rei-kit/styles.css'; /* compiled component styles */
+
+/* the whole rebrand */
+@theme {
+  --color-primary: #6b4de6;
+  --color-positive: #2fa36b;
+  --color-negative: #d1453b;
+}
+```
+
+Tokens are named for what they do, not for the app they came from, so a new
+product changes values rather than renaming anything.
+
+## Commands
+
+| Command          | What it does                                          |
+| ---------------- | ----------------------------------------------------- |
+| `pnpm dev`       | Rebuild on change, for use with a linked app          |
+| `pnpm build`     | Type-check, then build                                |
+| `pnpm check`     | Everything CI runs: format, lint, types, tests, build |
+| `pnpm test:unit` | Vitest, watch mode                                    |
+| `pnpm lint`      | oxlint + ESLint, with `--fix`                         |
+
+## Releasing
+
+Pushing a `v*` tag runs the full check and publishes to npm. Nothing publishes
+from a branch, so `main` can move without shipping.
+
+```sh
+pnpm version minor
+git push --follow-tags
+```
+
+## License
+
+MIT

package/dist/app-error-DF9cijE0.js

@@ -0,0 +1,63 @@
+//#region src/utils/app-error.ts
+/**
+* A normalised error thrown by the data layer.
+*
+* Extends `Error` so it can be thrown, caught and logged like any other error,
+* and keeps the original in `cause` for debugging.
+*
+* @example
+* ```ts
+* try {
+*   await createHabit(input)
+* } catch (e) {
+*   const err = toAppError(e)
+*   if (err.kind === 'conflict') return // already exists, not a real failure
+*   showToast(err.message)
+* }
+* ```
+*/
+var AppError = class extends Error {
+	kind;
+	constructor(kind, message, options) {
+		super(message, options);
+		this.name = "AppError";
+		this.kind = kind;
+	}
+};
+var mappers = [];
+/**
+* Teaches `toAppError` about a backend it does not import.
+*
+* The core has no database dependency; `rei-kit/supabase` registers the
+* Postgrest mapping when it is imported, so an app that never touches Supabase
+* never downloads the code that knows about it.
+*
+* @example
+* ```ts
+* registerErrorMapper((error) =>
+*   isPrismaConflict(error) ? new AppError('conflict', 'Already exists.') : null,
+* )
+* ```
+*/
+function registerErrorMapper(mapper) {
+	mappers.push(mapper);
+}
+/**
+* Normalises anything thrown by the data layer.
+*
+* @param error - Whatever was caught.
+* @returns An `AppError`, never a rethrow.
+*/
+function toAppError(error) {
+	if (error instanceof AppError) return error;
+	for (const map of mappers) {
+		const mapped = map(error);
+		if (mapped) return mapped;
+	}
+	if (error instanceof TypeError) return new AppError("network", "Could not reach the server.", { cause: error });
+	return new AppError("unknown", "Something went wrong.", { cause: error });
+}
+//#endregion
+export { registerErrorMapper as n, toAppError as r, AppError as t };
+
+//# sourceMappingURL=app-error-DF9cijE0.js.map

package/dist/app-error-DF9cijE0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-error-DF9cijE0.js","names":[],"sources":["../src/utils/app-error.ts"],"sourcesContent":["/** Error categories the UI can branch on, independent of Postgres or Supabase. */\nexport type AppErrorKind = 'conflict' | 'not-found' | 'network' | 'unknown'\n\n/**\n * A normalised error thrown by the data layer.\n *\n * Extends `Error` so it can be thrown, caught and logged like any other error,\n * and keeps the original in `cause` for debugging.\n *\n * @example\n * ```ts\n * try {\n *   await createHabit(input)\n * } catch (e) {\n *   const err = toAppError(e)\n *   if (err.kind === 'conflict') return // already exists, not a real failure\n *   showToast(err.message)\n * }\n * ```\n */\nexport class AppError extends Error {\n  readonly kind: AppErrorKind\n\n  constructor(kind: AppErrorKind, message: string, options?: ErrorOptions) {\n    super(message, options)\n    this.name = 'AppError'\n    this.kind = kind\n  }\n}\n\n/**\n * Normalises anything thrown by Supabase into an {@link AppError}.\n *\n * Idempotent: an `AppError` is returned as-is, so wrapping twice is safe.\n *\n * @param error - Anything caught from the data layer.\n * @returns An `AppError` with a user-facing message and a `kind` to branch on.\n */\n/**\n * Turns a backend-specific error into an `AppError`, or returns `null` to let\n * the next mapper try.\n */\nexport type ErrorMapper = (error: unknown) => AppError | null\n\nconst mappers: ErrorMapper[] = []\n\n/**\n * Teaches `toAppError` about a backend it does not import.\n *\n * The core has no database dependency; `rei-kit/supabase` registers the\n * Postgrest mapping when it is imported, so an app that never touches Supabase\n * never downloads the code that knows about it.\n *\n * @example\n * ```ts\n * registerErrorMapper((error) =>\n *   isPrismaConflict(error) ? new AppError('conflict', 'Already exists.') : null,\n * )\n * ```\n */\nexport function registerErrorMapper(mapper: ErrorMapper): void {\n  mappers.push(mapper)\n}\n\n/**\n * Normalises anything thrown by the data layer.\n *\n * @param error - Whatever was caught.\n * @returns An `AppError`, never a rethrow.\n */\nexport function toAppError(error: unknown): AppError {\n  if (error instanceof AppError) return error\n\n  for (const map of mappers) {\n    const mapped = map(error)\n    if (mapped) return mapped\n  }\n\n  // A failed fetch surfaces as a TypeError, which is the only reliable signal\n  // the browser gives that the request never left.\n  if (error instanceof TypeError) {\n    return new AppError('network', 'Could not reach the server.', { cause: error })\n  }\n\n  return new AppError('unknown', 'Something went wrong.', { cause: error })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAoBA,IAAa,WAAb,cAA8B,MAAM;CAClC;CAEA,YAAY,MAAoB,SAAiB,SAAwB;EACvE,MAAM,SAAS,OAAO;EACtB,KAAK,OAAO;EACZ,KAAK,OAAO;CACd;AACF;AAgBA,IAAM,UAAyB,CAAC;;;;;;;;;;;;;;;AAgBhC,SAAgB,oBAAoB,QAA2B;CAC7D,QAAQ,KAAK,MAAM;AACrB;;;;;;;AAQA,SAAgB,WAAW,OAA0B;CACnD,IAAI,iBAAiB,UAAU,OAAO;CAEtC,KAAK,MAAM,OAAO,SAAS;EACzB,MAAM,SAAS,IAAI,KAAK;EACxB,IAAI,QAAQ,OAAO;CACrB;CAIA,IAAI,iBAAiB,WACnB,OAAO,IAAI,SAAS,WAAW,+BAA+B,EAAE,OAAO,MAAM,CAAC;CAGhF,OAAO,IAAI,SAAS,WAAW,yBAAyB,EAAE,OAAO,MAAM,CAAC;AAC1E"}

package/dist/components/BaseButton.vue.d.ts

@@ -0,0 +1,20 @@
+type __VLS_Props = {
+    variant?: 'primary' | 'ghost' | 'danger';
+    size?: 'sm' | 'md';
+    loading?: boolean;
+    disabled?: boolean;
+    type?: 'button' | 'submit';
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BaseInput.vue.d.ts

@@ -0,0 +1,23 @@
+type __VLS_Props = {
+    label: string;
+    error?: string | undefined;
+    hint?: string | undefined;
+    /**
+     * Hides the label visually but keeps it for assistive tech. For fields whose
+     * surrounding row already names them — dropping the label entirely would
+     * leave the input with no accessible name at all.
+     */
+    labelHidden?: boolean;
+    type?: 'text' | 'email' | 'password' | 'number';
+};
+type __VLS_ModelProps = {
+    modelValue?: string | undefined;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: (value: string | undefined) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/BaseSheet.vue.d.ts

@@ -0,0 +1,32 @@
+type __VLS_Props = {
+    title: string;
+    subtitle?: string;
+    /**
+     * Accessible name for the close button.
+     *
+     * A prop rather than a translation: a component that calls t() forces every
+     * consumer onto one i18n setup, and this is the package's only visible string.
+     */
+    closeLabel?: string;
+};
+type __VLS_ModelProps = {
+    modelValue: boolean;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_18: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_18) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: (value: boolean) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/EmptyState.vue.d.ts

@@ -0,0 +1,19 @@
+type __VLS_Props = {
+    title: string;
+    description?: string | undefined;
+};
+declare var __VLS_1: {}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    icon?: (props: typeof __VLS_1) => any;
+} & {
+    action?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/LocaleLinks.vue.d.ts

@@ -0,0 +1,33 @@
+declare const __VLS_export: <L extends string>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<({
+        locales: readonly L[];
+        /** Endonyms, e.g. `{ en: 'English', tr: 'Türkçe' }`. */
+        labels: Record<L, string>;
+        /** Accessible name for the group. */
+        label?: string;
+    } & {
+        /**
+         * Two-way bound rather than taking the runtime's ref as a prop: props are not
+         * unwrapped in a template and cannot be assigned to, so the ref would compare
+         * against itself and the click handler would not compile.
+         */
+        modelValue: "system" | L;
+    }) & {
+        "onUpdate:modelValue"?: (value: "system" | L) => any;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: (event: "update:modelValue", value: "system" | L) => void;
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/PageHeader.vue.d.ts

@@ -0,0 +1,20 @@
+type __VLS_Props = {
+    title: string;
+};
+declare var __VLS_1: {}, __VLS_3: {}, __VLS_5: {};
+type __VLS_Slots = {} & {
+    left?: (props: typeof __VLS_1) => any;
+} & {
+    title?: (props: typeof __VLS_3) => any;
+} & {
+    right?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/SectionHeading.vue.d.ts

@@ -0,0 +1,26 @@
+/** The three classes a category needs to colour a heading. */
+export interface Tone {
+    /** Solid background for the dot, e.g. `bg-positive`. */
+    fill: string;
+    /** Tinted surface for the pill, e.g. `bg-positive/5 border-positive/25`. */
+    card: string;
+    /** Foreground that pairs with the surface, e.g. `text-positive`. */
+    text: string;
+}
+/**
+ * A pill heading for a group of things.
+ *
+ * The tone arrives as three class strings rather than a category name: Tailwind
+ * reads source files as plain text, so a class assembled at runtime never
+ * reaches the stylesheet — the app has to write them out, and it is the app
+ * that knows its own categories anyway.
+ */
+type __VLS_Props = {
+    tone: Tone;
+    label: string;
+    /** Hidden when zero, so an empty group's heading stays quiet. */
+    count?: number;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/SegmentedControl.vue.d.ts

@@ -0,0 +1,27 @@
+declare const __VLS_export: <T extends string | number>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import('vue').PublicProps & __VLS_PrettifyLocal<({
+        options: readonly {
+            value: T;
+            label: string;
+        }[];
+    } & {
+        modelValue: T;
+    }) & {
+        "onUpdate:modelValue"?: (value: T) => any;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {};
+    emit: (event: "update:modelValue", value: T) => void;
+}>) => import('vue').VNode & {
+    __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/components/SettingsGroup.vue.d.ts

@@ -0,0 +1,16 @@
+type __VLS_Props = {
+    title: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/SettingsRow.vue.d.ts

@@ -0,0 +1,35 @@
+import { Component } from 'vue';
+/**
+ * One line in a settings card.
+ *
+ * `as` decides the element: a row that navigates has to be a button, and a row
+ * that merely holds a control must not be, or the control becomes unreachable.
+ */
+type __VLS_Props = {
+    label: string;
+    description?: string;
+    icon?: Component | undefined;
+    /** Renders the row as a button with a chevron. */
+    interactive?: boolean;
+    /** Puts the control on its own line below the label, for wide controls. */
+    stacked?: boolean;
+};
+declare var __VLS_15: {}, __VLS_22: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_15) => any;
+} & {
+    default?: (props: typeof __VLS_22) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: () => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/SkeletonList.vue.d.ts

@@ -0,0 +1,8 @@
+type __VLS_Props = {
+    rows?: number;
+    rowHeight?: string;
+    label?: string;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/StatCard.vue.d.ts

@@ -0,0 +1,8 @@
+type __VLS_Props = {
+    value: string;
+    label: string;
+    trend?: 'up' | 'down' | 'flat' | null;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/ToneDot.vue.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A small coloured dot, optionally labelled.
+ *
+ * Takes the colour as a class rather than a category, so an app can key it off
+ * whatever its own domain calls a category — habit kinds, expense types,
+ * priorities — without this component knowing about any of them.
+ */
+type __VLS_Props = {
+    /** Background utility for the dot, e.g. `bg-positive`. */
+    fill: string;
+    /** Optional text after the dot. Omit for a bare marker. */
+    label?: string;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/composables/use-debounced-callback.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Delays a callback until the caller stops calling it.
+ *
+ * Used for note autosave: a request per keystroke would be wasteful, but losing
+ * the last keystrokes when the user navigates away would be worse — so the
+ * pending call is flushed on dispose, and `flush` is exposed for route guards.
+ *
+ * @param callback - Runs with the arguments of the most recent call.
+ * @param delay - Quiet period in milliseconds.
+ * @returns `run` to schedule, `flush` to run now, `cancel` to drop.
+ *
+ * @example
+ * ```ts
+ * const save = useDebouncedCallback((body: string) => mutate(body), 800)
+ * watch(text, (value) => save.run(value))
+ * onBeforeRouteLeave(() => save.flush())
+ * ```
+ */
+export declare function useDebouncedCallback<A extends unknown[]>(callback: (...args: A) => void, delay?: number): {
+    run: (...args: A) => void;
+    flush: () => void;
+    cancel: () => void;
+};

package/dist/composables/use-drag-scroll.d.ts

@@ -0,0 +1,26 @@
+import { Ref } from 'vue';
+/**
+ * Drag-to-scroll for a horizontally scrolling element.
+ *
+ * The app puts `touch-action: pan-y` on the page content so the tab-swipe
+ * gesture keeps its pointer events — the browser never claims a horizontal
+ * drag, which also means it never pans this element natively. Rather than give
+ * that up, horizontal scrolling is driven here.
+ *
+ * @param target - The scroll container.
+ * @returns `didDrag`, so a click handler can ignore the press that ended a drag.
+ *
+ * @example
+ * ```ts
+ * const scroller = ref<HTMLElement | null>(null)
+ * const { didDrag } = useDragScroll(scroller)
+ *
+ * function onClick() {
+ *   if (didDrag()) return
+ *   // …treat as a tap
+ * }
+ * ```
+ */
+export declare function useDragScroll(target: Ref<HTMLElement | null>): {
+    didDrag: () => boolean;
+};

package/dist/composables/use-online.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Tracks whether the browser thinks it has a network connection.
+ *
+ * Note the limit: `navigator.onLine` only reports whether a network interface
+ * is up, not whether requests actually succeed. Treat it as a hint for the UI,
+ * never as a reason to skip error handling.
+ *
+ * Listeners are removed on unmount, so the composable is safe to call per view.
+ *
+ * @returns A readonly ref that flips with the browser's online/offline events.
+ *
+ * @example
+ * ```ts
+ * const isOnline = useOnline()
+ * // <p v-if="!isOnline">You're offline.</p>
+ * ```
+ */
+export declare function useOnline(): Readonly<import('vue').Ref<boolean, boolean>>;

package/dist/composables/use-theme.d.ts

@@ -0,0 +1,23 @@
+import { Ref } from 'vue';
+/** What the user asked for; `system` follows the OS. */
+export type ThemePreference = 'system' | 'light' | 'dark';
+export declare function isThemePreference(value: unknown): value is ThemePreference;
+/** Reads the stored preference, falling back to `system`. */
+export declare function readStoredTheme(): ThemePreference;
+/** Adds or removes `.dark` on `<html>`, resolving `system` against the OS. */
+export declare function applyTheme(preference: ThemePreference): void;
+/**
+ * Sets where the preference is stored.
+ *
+ * Safe in either order: called before the first `useTheme()` it simply changes
+ * the key, and called after it re-reads under the new one, so the controller
+ * never reads from one key while writing to another.
+ *
+ * @example
+ * ```ts
+ * setThemeStorageKey('hibi-theme')   // once, at startup
+ * ```
+ */
+export declare function setThemeStorageKey(key: string): void;
+/** @returns The shared preference ref; assigning to it stores and applies it. */
+export declare function useTheme(): Ref<ThemePreference>;

package/dist/composables/use-today.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @returns Read-only ref holding today's `YYYY-MM-DD` key.
+ *
+ * @example
+ * ```ts
+ * const today = useToday()
+ * const isFuture = computed(() => day > today.value)
+ * ```
+ */
+export declare function useToday(): Readonly<import('vue').Ref<string, string>>;

package/dist/composables/use-visual-viewport.d.ts

@@ -0,0 +1,29 @@
+/** The visible area, once the on-screen keyboard has taken its share. */
+export interface VisualViewportRect {
+    height: number;
+    offsetTop: number;
+}
+/**
+ * Tracks the visual viewport.
+ *
+ * Chrome and Android browsers honour `interactive-widget=resizes-content`, so
+ * the layout viewport already shrinks for the keyboard there. Safari on iOS
+ * does not implement it: it shrinks only the *visual* viewport, leaving a sheet
+ * sized in `dvh` sitting partly underneath the keyboard.
+ *
+ * `null` means the API is unavailable, which callers should read as "trust the
+ * layout viewport" rather than as zero.
+ *
+ * @example
+ * ```ts
+ * const viewport = useVisualViewport()
+ * // :style="viewport ? { height: `${viewport.height}px` } : undefined"
+ * ```
+ */
+export declare function useVisualViewport(): Readonly<import('vue').Ref<{
+    readonly height: number;
+    readonly offsetTop: number;
+} | null, {
+    readonly height: number;
+    readonly offsetTop: number;
+} | null>>;