origam 2.15.0 → 2.17.0

package/dist/src/components/Section/OrigamSection.vue

@@ -1,9 +0,0 @@
-<template>
-	<div class="origam-section">
-
-	</div>
-</template>
-
-<script lang="ts" setup>
-
-</script>

package/dist/src/components/Section/index.cjs

@@ -1,13 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "OrigamSection", {
-  enumerable: true,
-  get: function () {
-    return _OrigamSection.default;
-  }
-});
-var _OrigamSection = _interopRequireDefault(require("./OrigamSection.vue"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/dist/src/components/Section/index.d.ts

@@ -1 +0,0 @@
-export { default as OrigamSection } from './OrigamSection.vue';

package/dist/src/components/Section/index.js

@@ -1 +0,0 @@
-export { default as OrigamSection } from "./OrigamSection.vue";

package/dist/src/composables/Commons/active.composable.cjs

@@ -1,53 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useActive = useActive;
-var _vue = require("vue");
-var _composables = require("../../composables/index.cjs");
-var _utils = require("../../utils/index.cjs");
-function useActive(props, prop = "active", name = (0, _utils.getCurrentInstanceName)()) {
-  const vmodel = (0, _composables.useVModel)(props, prop);
-  const activeState = (0, _vue.computed)(() => {
-    const v = props[prop];
-    return v && typeof v === "object" ? v : void 0;
-  });
-  const forced = (0, _vue.computed)(() => {
-    const v = props[prop];
-    if (v === true) return true;
-    if (v && typeof v === "object") return v.enabled === true;
-    return false;
-  });
-  const internalToggle = (0, _vue.ref)(false);
-  const isActive = (0, _vue.computed)(() => {
-    if (forced.value) return true;
-    const v = vmodel.value;
-    if (typeof v === "boolean") return v;
-    return internalToggle.value;
-  });
-  const activeClasses = (0, _vue.computed)(() => {
-    const classes = [];
-    if (isActive.value) {
-      classes.push(`${name}--active`);
-      if (props.activeClass) {
-        classes.push(props.activeClass);
-      }
-    }
-    return classes;
-  });
-  const onActive = () => {
-    const v = vmodel.value;
-    if (typeof v === "boolean" || v === void 0) {
-      vmodel.value = !isActive.value;
-    } else {
-      internalToggle.value = !internalToggle.value;
-    }
-  };
-  return {
-    isActive,
-    activeState,
-    activeClasses,
-    onActive
-  };
-}

package/dist/src/composables/Commons/active.composable.d.ts

@@ -1,41 +0,0 @@
-import type { ComputedRef } from "vue";
-import { IActiveProps } from "../../interfaces";
-/**
- * Track the active (pressed / selected) state of the host element AND
- * expose any style override the consumer attached to the `active` prop.
- *
- * `props.active` (or `props[prop]` when the caller binds a different
- * key like `modelValue`) accepts three shapes — mirrors `useHover`:
- *
- *   • `undefined` / `false` →
- *       isActive    : driven by `onActive()` toggle / v-model.
- *       activeState : undefined.
- *
- *   • `true` →
- *       isActive    : FORCED to `true`. (vmodel sync still works for
- *                     downstream emits, but `isActive` won't drop below
- *                     true while the prop is `true`.)
- *       activeState : undefined.
- *
- *   • `IActiveState` (object: `{ color?, bgColor?, border?, rounded?,
- *     elevation?, padding?, margin?, gap?, enabled? }`) →
- *       isActive    : reactive to `onActive()` (UNLESS `enabled: true`
- *                     is set, which forces it on).
- *       activeState : the object itself — consumed by `useStateEffect`.
- *
- * The `prop` argument lets callers bind a non-`active` key (e.g. Badge
- * and BottomNav use `'modelValue'`); the legacy v-model contract is
- * preserved on that key when it's a plain boolean.
- *
- * `activeClass` (legacy prop) still appends an extra class name when
- * the state is engaged — kept for compat with parent customisation.
- */
-/*********************************************************
- * useActive
- ********************************************************/
-export declare function useActive(props: IActiveProps & Record<string, any>, prop?: string, name?: string): {
-    isActive: ComputedRef<boolean>;
-    activeState: ComputedRef<import("../../interfaces").IStateEffectConfig | undefined>;
-    activeClasses: ComputedRef<string[]>;
-    onActive: () => void;
-};

package/dist/src/composables/Commons/active.composable.js

@@ -1,47 +0,0 @@
-import { computed, ref } from "vue";
-import { useVModel } from "../../composables/index.js";
-import { getCurrentInstanceName } from "../../utils/index.js";
-export function useActive(props, prop = "active", name = getCurrentInstanceName()) {
-  const vmodel = useVModel(props, prop);
-  const activeState = computed(() => {
-    const v = props[prop];
-    return v && typeof v === "object" ? v : void 0;
-  });
-  const forced = computed(() => {
-    const v = props[prop];
-    if (v === true) return true;
-    if (v && typeof v === "object") return v.enabled === true;
-    return false;
-  });
-  const internalToggle = ref(false);
-  const isActive = computed(() => {
-    if (forced.value) return true;
-    const v = vmodel.value;
-    if (typeof v === "boolean") return v;
-    return internalToggle.value;
-  });
-  const activeClasses = computed(() => {
-    const classes = [];
-    if (isActive.value) {
-      classes.push(`${name}--active`);
-      if (props.activeClass) {
-        classes.push(props.activeClass);
-      }
-    }
-    return classes;
-  });
-  const onActive = () => {
-    const v = vmodel.value;
-    if (typeof v === "boolean" || v === void 0) {
-      vmodel.value = !isActive.value;
-    } else {
-      internalToggle.value = !internalToggle.value;
-    }
-  };
-  return {
-    isActive,
-    activeState,
-    activeClasses,
-    onActive
-  };
-}

package/dist/src/composables/Commons/hover.composable.cjs

@@ -1,44 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useHover = useHover;
-var _vue = require("vue");
-var _utils = require("../../utils/index.cjs");
-function useHover(props, name = (0, _utils.getCurrentInstanceName)()) {
-  const isHovered = (0, _vue.ref)(false);
-  const forced = (0, _vue.computed)(() => {
-    const h = props.hover;
-    if (h === true) return true;
-    if (h && typeof h === "object") return h.enabled === true;
-    return false;
-  });
-  const hoverState = (0, _vue.computed)(() => {
-    const h = props.hover;
-    if (h && typeof h === "object") return h;
-    return void 0;
-  });
-  const isHover = (0, _vue.computed)(() => forced.value || isHovered.value);
-  const hoverClasses = (0, _vue.computed)(() => {
-    const classes = [];
-    if (isHover.value) {
-      classes.push(`${name}--hovered`);
-    }
-    return classes;
-  });
-  const onMouseenter = () => {
-    isHovered.value = true;
-  };
-  const onMouseleave = () => {
-    isHovered.value = false;
-  };
-  (0, _vue.watch)(() => props.hover, () => {});
-  return {
-    isHover,
-    hoverState,
-    hoverClasses,
-    onMouseenter,
-    onMouseleave
-  };
-}

package/dist/src/composables/Commons/hover.composable.d.ts

@@ -1,44 +0,0 @@
-import type { ComputedRef } from "vue";
-import type { IHoverProps } from "../../interfaces";
-/**
- * Track whether the host element is being hovered AND expose any
- * style override the consumer attached to the `hover` prop.
- *
- * `props.hover` accepts three shapes (mirrors `IHoverProps`):
- *
- *   • `undefined` / `false` →
- *       isHover    : reflects mouseenter/leave (default behaviour)
- *       hoverState : undefined (no style override — `useStateEffect`
- *                    falls back to resting tokens / auto-darkening)
- *
- *   • `true` →
- *       isHover    : FORCED to `true` regardless of pointer events
- *                    (stories, tests, parent-controlled state)
- *       hoverState : undefined
- *
- *   • `IHoverState` object (e.g. `{ bgColor: 'success', border: 'thick' }`) →
- *       isHover    : reactive to mouseenter/leave (UNLESS `enabled: true`
- *                    is set inside the object, which forces it on like
- *                    the bare `true` case)
- *       hoverState : the object itself — consumed by `useStateEffect`
- *                    to swap effective values per axis.
- *
- * `hoverClasses` stays in sync with `isHover` (`${name}--hovered`).
- *
- * Historical note: an earlier version required `props.hover === true`
- * as an opt-in gate before mouseenter/mouseleave would have any
- * effect. That meant every consumer of `hoverColor` / `hoverBgColor`
- * had to also pass `hover` — which nobody did, so the props were
- * silently dead. The current contract treats `props.hover` strictly
- * as a forcing / config override.
- */
-/*********************************************************
- * useHover
- ********************************************************/
-export declare function useHover(props: IHoverProps, name?: string): {
-    isHover: ComputedRef<boolean>;
-    hoverState: ComputedRef<import("../../interfaces").IStateEffectConfig | undefined>;
-    hoverClasses: ComputedRef<string[]>;
-    onMouseenter: () => void;
-    onMouseleave: () => void;
-};

package/dist/src/composables/Commons/hover.composable.js

@@ -1,39 +0,0 @@
-import { computed, ref, watch } from "vue";
-import { getCurrentInstanceName } from "../../utils/index.js";
-export function useHover(props, name = getCurrentInstanceName()) {
-  const isHovered = ref(false);
-  const forced = computed(() => {
-    const h = props.hover;
-    if (h === true) return true;
-    if (h && typeof h === "object") return h.enabled === true;
-    return false;
-  });
-  const hoverState = computed(() => {
-    const h = props.hover;
-    if (h && typeof h === "object") return h;
-    return void 0;
-  });
-  const isHover = computed(() => forced.value || isHovered.value);
-  const hoverClasses = computed(() => {
-    const classes = [];
-    if (isHover.value) {
-      classes.push(`${name}--hovered`);
-    }
-    return classes;
-  });
-  const onMouseenter = () => {
-    isHovered.value = true;
-  };
-  const onMouseleave = () => {
-    isHovered.value = false;
-  };
-  watch(() => props.hover, () => {
-  });
-  return {
-    isHover,
-    hoverState,
-    hoverClasses,
-    onMouseenter,
-    onMouseleave
-  };
-}

package/dist/src/composables/CssSupport/cssSupport.composable.d.ts

@@ -1,73 +0,0 @@
-import { type ComputedRef, type Ref } from 'vue';
-import { FEATURE_QUERIES } from '../../consts/CssSupport/css-support.const';
-export type TCssFeatureName = keyof typeof FEATURE_QUERIES;
-export type TCssSupportMap = Readonly<Record<TCssFeatureName, boolean>>;
-export interface IUseCssSupport {
-    /**
-     * Reactive map of feature → `boolean`. Computed once on first browser-
-     * side call; subsequent calls share the same frozen snapshot.
-     */
-    css: Readonly<Ref<TCssSupportMap>>;
-    /**
-     * Free-form query support. Pass any string accepted by `CSS.supports()`.
-     * Result is cached per-query.
-     *
-     * @example
-     *   supports('display: grid')                  // true on modern browsers
-     *   supports('selector(:has(*))')              // selector query
-     *   supports('width: clamp(1px, 50%, 100px)')  // math function
-     */
-    supports: (query: string) => boolean;
-    /**
-     * `true` if at least ONE of the queries is supported.
-     */
-    supportsAny: (...queries: string[]) => boolean;
-    /**
-     * `true` if EVERY query is supported.
-     */
-    supportsAll: (...queries: string[]) => boolean;
-    /**
-     * Reactive `ComputedRef<boolean>` for a single named feature. Useful in
-     * templates: `<div v-if="hasGrid">…`.
-     */
-    has: (feature: TCssFeatureName) => ComputedRef<boolean>;
-}
-/*********************************************************
- * useCssSupport
- ********************************************************/
-export declare function useCssSupport(): IUseCssSupport;
-/**
- * Test-only helper — clear the internal cache + re-detect on next call.
- * Not part of the public API; consumers must not depend on it.
- *
- * @internal
- */
-/*********************************************************
- * _resetCssSupportCache
- ********************************************************/
-export declare function _resetCssSupportCache(): void;
-export interface IUseCssSupportClientOptions {
-    /**
-     * Value returned during SSR and on the first client render (before
-     * `onMounted` fires). Pick the side of the branch that produces the
-     * smaller / safer markup — typically `false` (= JS fallback) so the
-     * server output stays universally compatible.
-     */
-    defaultValue?: boolean;
-}
-/*********************************************************
- * useCssSupportClient
- *
- * @description
- * Hydration-safe single-feature gate. Returns a `Ref<boolean>` that
- * starts at `defaultValue` and flips to the real support result on
- * `onMounted`. Use to gate **markup**, not styles — for style-only
- * branches prefer `useCssSupport().css.value.X` directly.
- *
- * @example
- *   const supportsContainer = useCssSupportClient('containerQueries')
- *   // template:
- *   //   <div v-if="supportsContainer">…CSS path…</div>
- *   //   <div v-else>…JS fallback path…</div>
- ********************************************************/
-export declare function useCssSupportClient(feature: TCssFeatureName | string, options?: IUseCssSupportClientOptions): Ref<boolean>;

package/dist/src/composables/Mask/index.cjs

@@ -1,16 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _mask = require("./mask.composable.cjs");
-Object.keys(_mask).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _mask[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _mask[key];
-    }
-  });
-});

package/dist/src/composables/Mask/index.d.ts

@@ -1 +0,0 @@
-export * from './mask.composable';

package/dist/src/composables/Mask/index.js

@@ -1 +0,0 @@
-export * from "./mask.composable.js";

package/dist/src/composables/Mask/mask.composable.d.ts

@@ -1,39 +0,0 @@
-import { MaybeRef, Ref } from 'vue';
-import type { IMaskOptions, IResolvedMaskConfig } from '../../interfaces';
-import type { TMask } from '../../types';
-/**
- * Public return shape of `useMask`.
- */
-export interface IUseMaskReturn {
-    masked: Ref<string>;
-    unmasked: Ref<string>;
-    isValid: Ref<boolean>;
-    complete: Ref<boolean>;
-    /**
-     * Imperatively re-run the formatter on a raw value
-     * (used by paste / external sync). Returns the new
-     * `unmasked` so callers can keep their model in sync.
-     */
-    setRaw: (raw: string) => string;
-    /**
-     * Currently resolved config (pattern + validator +
-     * required). `null` when no mask is active.
-     */
-    config: Ref<IResolvedMaskConfig | null>;
-}
-/**
- * Reactive mask engine — keeps `masked`, `unmasked`,
- * `isValid` and `complete` in sync with a source string
- * (`modelValue`) and a (possibly polymorphic) mask spec.
- *
- * Both the value and the mask are accepted as a `MaybeRef`
- * so the composable plays well with `props.modelValue` and
- * a static `props.mask` alike.
- *
- * Reactivity:
- *   - When `modelValue` changes → reformat + revalidate.
- *   - When `mask` changes      → re-resolve config, reformat
- *                                the current value.
- */
-export declare function useMask(modelValue: MaybeRef<string | null | undefined>, mask: MaybeRef<TMask | undefined>): IUseMaskReturn;
-export type { IMaskOptions };

package/dist/src/composables/Theme/installed-themes.composable.d.ts

@@ -1,19 +0,0 @@
-import type { TInstalledThemes } from '../../types';
-/**
- * `useInstalledThemes()` returns the list of brand themes installed via
- * `createOrigam({ themes })` — one entry per distinct brand `name`, each
- * listing the concrete modes it was installed for.
- *
- * Consumers (e.g. a theme switcher) map over this list instead of hard-coding
- * the available brands, so the UI stays in sync with whatever the app
- * installed. Returns an empty array when no themes were installed (or when
- * called outside an app that ran `createOrigam`), so callers never need a
- * null-guard.
- *
- * The list is static (snapshot at install time); pair it with `useTheme()` to
- * read / switch the active brand and mode.
- */
-/*********************************************************
- * useInstalledThemes
- ********************************************************/
-export declare function useInstalledThemes(): TInstalledThemes;

package/dist/src/composables/Theme/theme.composable.d.ts

@@ -1,85 +0,0 @@
-import type { Ref } from 'vue';
-import type { TMode, TModeResolved, TTheme, TThemeResolved } from '../../types/Theme/theme.type';
-/**
- * `useTheme()` returns a shared, reactive handle over the two theming axes.
- *
- * ### Brand axis (`theme` / `data-theme`)
- * - `theme` (read-only ref): the current brand — `'auto' | 'light' | 'dark' | string`.
- * - `setTheme(t)`: imperative setter. Persists to `localStorage` and applies
- *   `data-theme` to `<html>`.
- * - `resolved` (computed): the effective theme after resolving `'auto'`
- *   against `prefers-color-scheme`. Useful for SVG asset switching.
- * - `toggle()`: convenience to flip the brand light ↔ dark (treats `'auto'`
- *   as light). Kept for back-compat with the single-axis API.
- *
- * ### Mode axis (`mode` / `data-mode`)
- * - `mode` (read-only ref): the current color mode — `'auto' | 'light' | 'dark'`.
- * - `setMode(m)`: imperative setter. Persists to `localStorage` and applies
- *   `data-mode` to `<html>`.
- * - `resolvedMode` (computed): the effective mode after resolving `'auto'`
- *   against `prefers-color-scheme`.
- * - `toggleMode()`: flip the color mode light ↔ dark (treats `'auto'` as the
- *   current system preference).
- *
- * The media-query listener is a lazily-initialised SINGLETON (see
- * `ensureSystemPreference`) rather than an `onMounted` hook, so `resolvedMode`
- * is correct even when `useTheme()` is first called outside a component (e.g.
- * a Nuxt plugin). SSR stays safe — the init is a no-op without `window`.
- */
-/*********************************************************
- * useTheme
- ********************************************************/
-export declare function useTheme(): {
-    theme: Readonly<Ref<TTheme, TTheme>>;
-    resolved: Readonly<Ref<TThemeResolved, TThemeResolved>>;
-    setTheme: (next: TTheme) => void;
-    toggle: () => void;
-    mode: Readonly<Ref<TMode, TMode>>;
-    resolvedMode: Readonly<Ref<TModeResolved, TModeResolved>>;
-    setMode: (next: TMode) => void;
-    toggleMode: () => void;
-};
-/**
- * Internal helper for SSR / no-flash plugins: apply a theme (brand) to the
- * document synchronously (called BEFORE first render). Bypasses Vue reactivity.
- */
-/*********************************************************
- * applyThemeSync
- ********************************************************/
-export declare function applyThemeSync(theme: TTheme): void;
-/**
- * Internal helper for SSR / no-flash plugins: apply a CONCRETE mode to the
- * document synchronously. Bypasses Vue reactivity. An `'auto'` argument is
- * resolved against the current `prefers-color-scheme` (falling back to
- * `'light'` when unavailable) so `data-mode` always ends up concrete — the
- * token matrix has no mode-less fallback.
- */
-/*********************************************************
- * applyModeSync
- ********************************************************/
-export declare function applyModeSync(mode: TMode): void;
-/**
- * Internal helper for SSR / no-flash plugins: read the persisted theme (brand)
- * from localStorage without instantiating the composable.
- */
-/*********************************************************
- * readPersistedTheme
- ********************************************************/
-export declare function readPersistedTheme(): TTheme;
-/**
- * Internal helper for SSR / no-flash plugins: read the persisted mode from
- * localStorage without instantiating the composable.
- */
-/*********************************************************
- * readPersistedMode
- ********************************************************/
-export declare function readPersistedMode(): TMode;
-/**
- * Test-only: clear the module-level singletons (theme / mode refs and the
- * `prefers-color-scheme` cache) so each spec starts from a clean slate. Not
- * part of the public API.
- */
-/*********************************************************
- * _resetThemeForTesting
- ********************************************************/
-export declare function _resetThemeForTesting(): void;

package/dist/src/interfaces/Commons/calendar.interface.d.ts

@@ -1,33 +0,0 @@
-import type { TCalendarStrategy } from "../../types";
-export interface ICalendarProps {
-    allowedDates?: Array<unknown> | ((date: unknown) => boolean);
-    disabled?: boolean;
-    displayValue?: unknown;
-    date?: ReadonlyArray<unknown> | Array<unknown>;
-    month?: number;
-    max?: unknown;
-    min?: unknown;
-    showAdjacentMonths?: boolean;
-    year?: number;
-    weekdays?: Array<number>;
-    weeksInMonth?: TCalendarStrategy;
-    firstDayOfWeek?: number;
-}
-export interface IDay {
-    date: unknown;
-    isoDate: string;
-    formatted: string;
-    year: number;
-    month: number;
-    isDisabled: boolean;
-    isWeekStart: boolean;
-    isWeekEnd: boolean;
-    isToday: boolean;
-    isAdjacent: boolean;
-    isHidden: boolean;
-    isStart: boolean;
-    isSelected: boolean;
-    isEnd: boolean;
-    isSame: boolean;
-    localized: string;
-}