@sepale/components 0.0.0-stage → 0.1.0

package/dist/theme.js

@@ -0,0 +1,226 @@
+/**
+ * Theme model.
+ *
+ * A *family* is a set of opinionated classes **with its own set of
+ * variables**. Sharing a variable name with another family is a convenience,
+ * never a rule. This module does not decide what a family exposes: it reads
+ * the declaration out of the registry and serialises the edited values back
+ * to a drop-in `:root { … }` stylesheet.
+ *
+ * Which inks are parameters is the family's call: daisy exposes every one
+ * (`--color-primary-content`, as daisyUI does), the others derive theirs in
+ * CSS (`--color-on-primary`, see each family's `_root.scss`). A colour token
+ * says which variable holds its ink through `on`; nothing here reads a name.
+ */
+const TOKEN_TYPES = ['color', 'length', 'number', 'text', 'edge-width', 'shadows'];
+/** Units offered for editable lengths. `%` is excluded on purpose: it is
+ *  meaningless on a border and unreadable on a slider. */
+export const LENGTH_UNITS = ['px', 'rem', 'em', 'ch'];
+/**
+ * Split a CSS length into its number and its unit (`"0.5rem"` → `[0.5, 'rem']`).
+ *
+ * A four-value shorthand — `1px 0 1px 0`, an edge set — reads back as its
+ * first non-zero part, which is exactly the number that was typed.
+ */
+export function splitLength(value, fallbackUnit = 'rem') {
+    const parts = String(value).trim().split(/\s+/);
+    const pick = parts.find((p) => p !== '0' && !/^0[a-z%]*$/i.test(p)) ?? parts[0] ?? '0';
+    const m = pick.match(/^(-?[\d.]+)\s*([a-z%]*)$/i);
+    if (!m)
+        return [0, fallbackUnit];
+    return [parseFloat(m[1]) || 0, m[2] || fallbackUnit];
+}
+export const SIDES = ['top', 'right', 'bottom', 'left'];
+/** A width and its edges as one shorthand. All four on → just the length. */
+export function edgeWidthToCss({ width, sides }) {
+    const e = (s) => (sides[s] ? width : '0');
+    return sides.top && sides.right && sides.bottom && sides.left
+        ? width
+        : `${e('top')} ${e('right')} ${e('bottom')} ${e('left')}`;
+}
+/** And back. A part at `0` is an edge that is off. */
+export function edgeWidthFromCss(raw, fallbackUnit = 'px') {
+    const p = raw.trim().split(/\s+/);
+    const zero = (x) => x === '0' || /^0[a-z%]*$/i.test(x);
+    const [n, u] = splitLength(raw, fallbackUnit);
+    if (p.length !== 4) {
+        const on = !zero(p[0] ?? '0');
+        return { width: `${n}${u}`, sides: { top: on, right: on, bottom: on, left: on } };
+    }
+    return {
+        width: `${n}${u}`,
+        sides: { top: !zero(p[0] ?? '0'), right: !zero(p[1] ?? '0'), bottom: !zero(p[2] ?? '0'), left: !zero(p[3] ?? '0') }
+    };
+}
+/** The layers as CSS. An empty list is `none`, not an empty string. */
+export function shadowsToCss(layers) {
+    if (!layers.length)
+        return 'none';
+    return layers
+        .map((l) => `${l.inset ? 'inset ' : ''}${l.x} ${l.y} ${l.blur} ${l.spread} ${l.color}`)
+        .join(', ');
+}
+/** Split on the commas at depth 0 — not the ones inside `oklch(…)`. */
+function splitTop(v, sep) {
+    const out = [];
+    let depth = 0;
+    let acc = '';
+    for (const ch of v) {
+        if (ch === '(')
+            depth++;
+        if (ch === ')')
+            depth--;
+        if (depth === 0 && sep(ch)) {
+            if (acc.trim())
+                out.push(acc.trim());
+            acc = '';
+        }
+        else
+            acc += ch;
+    }
+    if (acc.trim())
+        out.push(acc.trim());
+    return out;
+}
+/**
+ * And back. A layer is up to four lengths and a colour, in any order the
+ * spec allows; whatever is not a length is the colour.
+ */
+export function shadowsFromCss(raw) {
+    const v = raw.trim();
+    if (!v || v === 'none' || v === 'initial')
+        return [];
+    return splitTop(v, (ch) => ch === ',').map((layer) => {
+        const words = splitTop(layer, (ch) => /\s/.test(ch));
+        const inset = words.includes('inset');
+        const rest = words.filter((w) => w !== 'inset');
+        const lengths = rest.filter((x) => /^-?[\d.]/.test(x) || x.startsWith('calc('));
+        const color = rest.filter((x) => !lengths.includes(x)).join(' ') || 'currentColor';
+        return {
+            x: lengths[0] ?? '0px',
+            y: lengths[1] ?? '0px',
+            blur: lengths[2] ?? '0px',
+            spread: lengths[3] ?? '0px',
+            color,
+            inset
+        };
+    });
+}
+/* ------------------------------------------------------------------ *
+ * Theme files
+ * ------------------------------------------------------------------ */
+/**
+ * Read a theme file — any stylesheet of `--name: value;` declarations — back
+ * into variables. A theme IS its variables, so this is all it takes; the
+ * family then keeps the ones it declares (see `tokensForFamily`).
+ */
+export function parseTheme(css) {
+    const clean = css.replace(/\/\*[\s\S]*?\*\//g, '');
+    /* No prototype: a file may name a variable `__proto__`. */
+    const vars = Object.create(null);
+    for (const [, name, value] of clean.matchAll(/--([\w-]+)\s*:\s*([^;}]+)/g)) {
+        /* The file is not ours: a value that could leave its declaration is
+           dropped, and the family's default stands (see "What may be written"). */
+        const v = value.trim();
+        if (isSafeName(name) && isSafeValue(v))
+            vars[name] = v;
+    }
+    const scheme = safeScheme(clean.match(/(?:^|[\s;{])color-scheme\s*:\s*([^;}]+)/)?.[1]);
+    return { vars, scheme };
+}
+import { paramsByFamily, familyDocs } from './generated/registry.js';
+/**
+ * Every family declares its own parameters in its SCSS; the build reads them
+ * back out and the registry hands them here. Nothing in this file decides what
+ * a family exposes — a family with five surfaces, or with none, or with a
+ * typeface, comes through unchanged.
+ */
+function fromParam(p) {
+    return {
+        name: p.name,
+        label: p.label,
+        group: p.group,
+        type: (TOKEN_TYPES.includes(p.type) ? p.type : 'text'),
+        value: p.value,
+        description: p.description,
+        min: p.min,
+        max: p.max,
+        step: p.step,
+        unit: p.unit,
+        units: p.units,
+        kind: p.kind,
+        on: p.on
+    };
+}
+/** A neutral fallback for the rare caller with no family in hand. */
+export const defaultTheme = (paramsByFamily[Object.keys(paramsByFamily)[0]] ?? []).map(fromParam);
+/** Human label of each family's design language, taken from its own header. */
+export const familyCategory = Object.fromEntries(Object.entries(familyDocs).map(([name, doc]) => [name, doc.after.replace(/^after /, '')]));
+/* ------------------------------------------------------------------ *
+ * What may be written into a stylesheet
+ *
+ * Theme values reach the page as CSS TEXT: the app writes them into a
+ * <style> element (routes/+layout.svelte), and they can come from files the
+ * user did not write — an imported theme, a family loaded from disk. A value
+ * holding `</style><img onerror=…>` would leave the stylesheet and run as
+ * script; one holding `}` or `;` would add rules of its own; one holding
+ * `url(` would make the browser fetch an address. So a name is a CSS ident,
+ * a value is a plain CSS value, a scheme is one of the keywords, and anything
+ * else is dropped. Applied where the text is written AND where files are
+ * read, so neither depends on the other.
+ * ------------------------------------------------------------------ */
+const SAFE_NAME = /^[a-zA-Z][\w-]{0,79}$/;
+/* Markup, blocks, declarations, escapes, comments, at-rules, and anything
+   that loads or evaluates something. */
+const UNSAFE_VALUE = /[<>{};\\`]|\/\*|\*\/|@|url\s*\(|image-set|image\s*\(|src\s*\(|expression|javascript:|attr\s*\(/i;
+const SCHEMES = new Set(['normal', 'light', 'dark', 'light dark', 'dark light', 'only light', 'only dark']);
+/** A custom property name (without `--`) safe to write. */
+export const isSafeName = (name) => typeof name === 'string' && SAFE_NAME.test(name);
+/** A value safe to write after `--name:`: no way out of the declaration. */
+export function isSafeValue(value) {
+    if (typeof value !== 'string' || value.length > 400 || UNSAFE_VALUE.test(value))
+        return false;
+    /* An unbalanced quote would swallow what follows it. */
+    return (value.split('"').length - 1) % 2 === 0 && (value.split("'").length - 1) % 2 === 0;
+}
+/** A `color-scheme` keyword, or undefined. */
+export function safeScheme(scheme) {
+    if (typeof scheme !== 'string')
+        return undefined;
+    const s = scheme.trim().replace(/\s+/g, ' ').toLowerCase();
+    return SCHEMES.has(s) ? s : undefined;
+}
+const safeTokens = (tokens) => tokens.filter((t) => isSafeName(t.name) && isSafeValue(t.value));
+/** Convert tokens into an inline `style` string for a preview element. */
+export function tokensToInlineStyle(tokens) {
+    return safeTokens(tokens)
+        .map((t) => `--${t.name}:${t.value}`)
+        .join(';');
+}
+/** Serialise tokens into a drop-in `:root { … }` stylesheet. */
+export function serializeTheme(tokens, scheme) {
+    const lines = safeTokens(tokens).map((t) => `\t--${t.name}: ${t.value};`);
+    const keyword = safeScheme(scheme);
+    if (keyword)
+        lines.unshift(`\tcolor-scheme: ${keyword};`);
+    return `:root {\n${lines.join('\n')}\n}\n`;
+}
+/** Deep copy so callers can edit without mutating the schema. */
+export function cloneTheme(tokens = defaultTheme) {
+    return tokens.map((t) => ({ ...t }));
+}
+/**
+ * Editable tokens for a family: exactly the parameters that family declares,
+ * seeded from `vars` (a theme's parsed custom properties) where present and
+ * from the family's own default otherwise.
+ */
+export function tokensForFamily(family, vars = {}) {
+    return tokensFrom(paramsByFamily[family] ?? [], vars);
+}
+/** The same, from a parameter list in hand — a family the build never saw. */
+export function tokensFrom(params, vars = {}) {
+    return params.map((p) => {
+        const token = fromParam(p);
+        return { ...token, value: vars[p.name] ?? token.value };
+    });
+}

package/dist/variants.d.ts

@@ -0,0 +1,124 @@
+/**
+ * The plumbing behind a component's AXES and FLAGS blocks — in THIS source
+ * only. The copy of a component generated for a family has none of it: the
+ * build writes its props and classes out by hand (scripts/gen-components.mjs).
+ *
+ * An AXIS is a group of mutually exclusive variants of one component, named
+ * after what it impacts, written as the list of values its prop accepts. The
+ * class a value writes follows two rules, and nothing else:
+ *
+ *   variant: ['outline', 'dash']   variant="dash"  →  .btn-dash
+ *   shadow:  ['none', 'reverse']   shadow="none"   →  .btn-noshadow
+ *   s:       ['1', '2', '3']       s="1"           →  .text-s1
+ *
+ * `none` writes `no<axis>`; a number writes `<axis><number>`; any other value
+ * writes itself. No prop at all writes nothing: the component's default look.
+ *
+ * A FLAG is a class that excludes nothing, written by a boolean prop. FLAGS
+ * maps each class suffix to the doc of its prop; the prop is the suffix in
+ * camelCase (`image-full` → `imageFull`).
+ */
+/** One axis: the values its prop accepts. */
+export type Axis = readonly string[];
+/** One component's flags: class suffix → what the prop does. */
+export type Flags = Readonly<Record<string, string>>;
+/** The values an axis accepts. Empty axis → `never`. */
+export type Values<A> = A extends readonly (infer V extends string)[] ? V : never;
+/** `image-full` → `imageFull`. */
+export type Camel<S extends string> = S extends `${infer H}-${infer T}` ? `${H}${Capitalize<Camel<T>>}` : S;
+declare global {
+    namespace Sepale {
+        /** family → component namespace → what the family draws. Filled by the
+         *  families' `.css.d.ts`, never by hand. */
+        interface Families {
+        }
+        /** `portable: true` keeps only what EVERY registered family ships (the
+         *  intersection), so switching between them never breaks a build. By
+         *  default a prop accepts what ANY of them ships (the union). */
+        interface Config {
+        }
+    }
+}
+/** The registered families' names; `never` when none is. */
+type Registered = keyof Sepale.Families;
+type Portable = Sepale.Config extends {
+    portable: true;
+} ? true : false;
+/** A namespace a family does not style: nothing drawn. (Not `never`, which
+ *  would satisfy every `extends` test below.) */
+type Unstyled = {
+    axes: {};
+    flags: never;
+    background: false;
+};
+/** What family `Fam` draws for namespace `P`. */
+type Entry<Fam, P extends string> = Fam extends Registered ? P extends keyof Sepale.Families[Fam] ? Sepale.Families[Fam][P] : Unstyled : Unstyled;
+/** The values of axis `K` family `Fam` ships (distributes over `Fam`). */
+type FamValues<Fam, P extends string, K> = Fam extends Registered ? Entry<Fam, P> extends {
+    axes: infer X;
+} ? K extends keyof X ? X[K] : never : never : never;
+/** The flag suffixes family `Fam` draws (distributes over `Fam`). */
+type FamFlags<Fam, P extends string> = Fam extends Registered ? Entry<Fam, P> extends {
+    flags: infer L;
+} ? L : never : never;
+/** `true` for each registered family that reads the `--<P>-bg` slot. */
+type FamBackground<Fam, P extends string> = Fam extends Registered ? Entry<Fam, P> extends {
+    background: true;
+} ? true : false : never;
+/** Whether props narrow at all: a namespace is given and a family registered. */
+type Narrows<P extends string> = [P] extends [never] ? false : [Registered] extends [never] ? false : true;
+/** Of an axis's values, what the registered families accept: any of them
+ *  (union), or every one of them when portable (intersection). */
+type AcceptedValues<P extends string, K, Wide> = Narrows<P> extends false ? Wide : Portable extends true ? Exclude<Wide, {
+    [Fam in Registered]: Exclude<Wide, FamValues<Fam, P, K>>;
+}[Registered]> : Extract<FamValues<Registered, P, K>, Wide>;
+/** `K` if the registered families draw flag `K`, else `never`. */
+type AcceptedFlag<P extends string, K> = Narrows<P> extends false ? K : Portable extends true ? Exclude<K, {
+    [Fam in Registered]: Exclude<K, FamFlags<Fam, P>>;
+}[Registered]> : Extract<FamFlags<Registered, P>, K>;
+/** Whether `background` is offered: some registered family reads the slot
+ *  (every one, when portable). */
+type HasBackground<P extends string> = Narrows<P> extends false ? true : Portable extends true ? false extends FamBackground<Registered, P> ? false : [FamBackground<Registered, P>] extends [never] ? false : true : true extends FamBackground<Registered, P> ? true : false;
+/**
+ * One optional prop per axis, typed to that axis's values — and NO prop at all
+ * for an axis left empty — plus one boolean per flag, and `background`.
+ *
+ * `P` is the component's namespace (`typeof PREFIX`). With it, the props follow
+ * the registered families (see `Sepale.Families` above): an axis value, a flag
+ * or `background` the families do not draw is not offered. Without a
+ * registered family — or without `P` — they are the full, generic set.
+ */
+export type AxisProps<A extends Record<string, Axis>, F extends Flags = {}, P extends string = never> = {
+    [K in keyof A as [AcceptedValues<P, K, Values<A[K]>>] extends [never] ? never : K]?: AcceptedValues<P, K, Values<A[K]>>;
+} & {
+    [K in keyof F & string as [AcceptedFlag<P, K>] extends [never] ? never : Camel<K>]?: boolean;
+} & (HasBackground<P> extends true ? {
+    /**
+     * A one-off fill, BY VALUE — `background="#efb"`, not a token name.
+     *
+     * It writes `--<prefix>-bg` inline, the slot a component that paints a
+     * fill reads. It deliberately does NOT take a semantic: `color` is
+     * already the axis for that. Offered only when a registered family
+     * reads the slot.
+     */
+    background?: string;
+} : {});
+/** The class one axis value writes. See the rules above. */
+export declare function axisClass(prefix: string, axis: string, value: string): string;
+/** `image-full` → `imageFull`. */
+export declare function camel(name: string): string;
+/** Join truthy class fragments into a single class string. */
+export declare function cx(...parts: Array<string | false | null | undefined>): string;
+/**
+ * Resolve every axis and flag into class names, and hand back everything that
+ * was NOT one so it can be spread onto the element.
+ *
+ * The component never names an axis individually — it passes the whole rest
+ * object through here. A value outside its axis resolves to nothing, and every
+ * axis and flag is removed from the rest, so none leaks out as a DOM attribute.
+ */
+export declare function applyAxes(prefix: string, axes: Record<string, Axis>, flags: Flags, props: Record<string, unknown>): {
+    classes: string;
+    rest: Record<string, unknown>;
+};
+export {};

package/dist/variants.js

@@ -0,0 +1,70 @@
+/**
+ * The plumbing behind a component's AXES and FLAGS blocks — in THIS source
+ * only. The copy of a component generated for a family has none of it: the
+ * build writes its props and classes out by hand (scripts/gen-components.mjs).
+ *
+ * An AXIS is a group of mutually exclusive variants of one component, named
+ * after what it impacts, written as the list of values its prop accepts. The
+ * class a value writes follows two rules, and nothing else:
+ *
+ *   variant: ['outline', 'dash']   variant="dash"  →  .btn-dash
+ *   shadow:  ['none', 'reverse']   shadow="none"   →  .btn-noshadow
+ *   s:       ['1', '2', '3']       s="1"           →  .text-s1
+ *
+ * `none` writes `no<axis>`; a number writes `<axis><number>`; any other value
+ * writes itself. No prop at all writes nothing: the component's default look.
+ *
+ * A FLAG is a class that excludes nothing, written by a boolean prop. FLAGS
+ * maps each class suffix to the doc of its prop; the prop is the suffix in
+ * camelCase (`image-full` → `imageFull`).
+ */
+/** The class one axis value writes. See the rules above. */
+export function axisClass(prefix, axis, value) {
+    if (value === 'none')
+        return `${prefix}-no${axis}`;
+    if (/^\d+$/.test(value))
+        return `${prefix}-${axis}${value}`;
+    return `${prefix}-${value}`;
+}
+/** `image-full` → `imageFull`. */
+export function camel(name) {
+    return name.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+/** Join truthy class fragments into a single class string. */
+export function cx(...parts) {
+    return parts.filter(Boolean).join(' ');
+}
+/**
+ * Resolve every axis and flag into class names, and hand back everything that
+ * was NOT one so it can be spread onto the element.
+ *
+ * The component never names an axis individually — it passes the whole rest
+ * object through here. A value outside its axis resolves to nothing, and every
+ * axis and flag is removed from the rest, so none leaks out as a DOM attribute.
+ */
+export function applyAxes(prefix, axes, flags, props) {
+    const out = [];
+    const rest = { ...props };
+    /* `background` is not an axis — it writes a value, not a class — but it
+       belongs here because `rest` is what every component spreads onto its
+       element. A caller's own `style` still wins by being written last. */
+    const bg = rest.background;
+    delete rest.background;
+    if (typeof bg === 'string' && bg) {
+        const own = typeof rest.style === 'string' ? rest.style : '';
+        rest.style = `--${prefix}-bg: ${bg};` + (own ? ` ${own}` : '');
+    }
+    for (const [name, values] of Object.entries(axes)) {
+        const value = rest[name];
+        delete rest[name];
+        if (typeof value === 'string' && values.includes(value))
+            out.push(axisClass(prefix, name, value));
+    }
+    for (const name of Object.keys(flags)) {
+        const prop = camel(name);
+        if (rest[prop])
+            out.push(`${prefix}-${name}`);
+        delete rest[prop];
+    }
+    return { classes: out.join(' '), rest };
+}

package/dist/vendor/air-datepicker/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Timofey Marochkin
+
+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/dist/vendor/air-datepicker/README.md

@@ -0,0 +1,19 @@
+# air-datepicker, vendored
+
+[air-datepicker](https://air-datepicker.com) 3.6.0 by Timofey Marochkin, MIT
+(see `LICENSE.md`), copied from its repository's `src/` (tag `v3.6.0`) so the
+`Calendar` component carries it: no npm dependency, and a family's copy of
+`Calendar.svelte` ships with this folder next to it.
+
+Changes to the source, and nothing else:
+
+- the `import './*.scss'` lines are gone: the library's stylesheet is not
+  used. Each family draws the calendar in its `calendar.scss`, scoped under
+  `.calendar` (the class `Calendar` puts on the picker's root).
+- relative imports carry their `.js` extension.
+- the default locale is English (`locale/en.js`) instead of Russian.
+- a `// @ts-nocheck` header on every file: typed by `index.d.ts` (the
+  library's own `src/datepicker.d.ts`), not checked line by line.
+
+To update: copy `src/*.js` and `src/locale/*.js` from a new tag and reapply
+the four changes above.

package/dist/vendor/air-datepicker/buttonPresets.d.ts

@@ -0,0 +1,13 @@
+declare namespace _default {
+    namespace today {
+        function content(dp: any): any;
+        function onClick(dp: any): any;
+    }
+    namespace clear {
+        export function content_1(dp: any): any;
+        export { content_1 as content };
+        export function onClick_1(dp: any): any;
+        export { onClick_1 as onClick };
+    }
+}
+export default _default;

package/dist/vendor/air-datepicker/buttonPresets.js

@@ -0,0 +1,12 @@
+// @ts-nocheck — vendored code, typed by index.d.ts; not ours to check.
+// air-datepicker 3.6.0 (MIT, Timofey Marochkin) — see LICENSE.md and README.md.
+export default {
+    today: {
+        content: dp => dp.locale.today,
+        onClick: dp => dp.setViewDate(new Date()),
+    },
+    clear: {
+        content: dp => dp.locale.clear,
+        onClick: dp => dp.clear()
+    }
+};

package/dist/vendor/air-datepicker/consts.d.ts

@@ -0,0 +1,18 @@
+declare namespace _default {
+    let days: string;
+    let months: string;
+    let years: string;
+    let day: string;
+    let month: string;
+    let year: string;
+    let eventChangeViewDate: string;
+    let eventChangeCurrentView: string;
+    let eventChangeFocusDate: string;
+    let eventChangeSelectedDate: string;
+    let eventChangeTime: string;
+    let eventChangeLastSelectedDate: string;
+    let actionSelectDate: string;
+    let actionUnselectDate: string;
+    let cssClassWeekend: string;
+}
+export default _default;

package/dist/vendor/air-datepicker/consts.js

@@ -0,0 +1,35 @@
+// @ts-nocheck — vendored code, typed by index.d.ts; not ours to check.
+// air-datepicker 3.6.0 (MIT, Timofey Marochkin) — see LICENSE.md and README.md.
+export default {
+    days: 'days',
+    months: 'months',
+    years: 'years',
+    day: 'day',
+    month: 'month',
+    year: 'year',
+
+    eventChangeViewDate: 'changeViewDate',
+    eventChangeCurrentView: 'changeCurrentView',
+
+    /**
+     * @param {Boolean} [viewDateTransition] - should perform transition to new viewDate
+     * if passed date is out current month/year/decade range
+     */
+    eventChangeFocusDate: 'changeFocusDate',
+
+    /**
+     * @param {String} action
+     * @param {Date} date
+     * @param {Boolean} [updateTime] - if true, then timepicker will take time from passed date and save it to instance
+     * @param {Boolean} [silent] - if true, then onChange event wont be triggered
+     */
+    eventChangeSelectedDate: 'changeSelectedDate',
+
+    eventChangeTime: 'changeTime',
+    eventChangeLastSelectedDate: 'changeLastSelectedDate',
+
+    actionSelectDate: 'selectDate',
+    actionUnselectDate: 'unselectDate',
+
+    cssClassWeekend: '-weekend-'
+};