v-calendar-3 1.0.0

package/dist/types/utils/attribute.d.ts

@@ -0,0 +1,49 @@
+import type { Placement } from '@popperjs/core';
+import { DateRange, type DateRangeSource } from './date/range';
+import { Bar, BarConfig, Content, ContentConfig, Dot, DotConfig, Highlight, HighlightConfig, Profile } from './glyph';
+import Locale from './locale';
+import type { PopoverVisibility } from './popovers';
+import { Theme } from './theme';
+export type PopoverConfig = Partial<{
+    label: string;
+    visibility: PopoverVisibility;
+    placement: Placement;
+    hideIndicator: boolean;
+    isInteractive: boolean;
+}>;
+export type EventConfig = Partial<{
+    label: string;
+}>;
+export type AttributeConfig = Partial<{
+    key: string | number;
+    hashcode: string;
+    content: ContentConfig;
+    highlight: HighlightConfig;
+    dot: DotConfig;
+    bar: BarConfig;
+    popover: PopoverConfig;
+    event: EventConfig;
+    dates: DateRangeSource[];
+    customData: any;
+    order: number;
+    pinPage: boolean;
+}>;
+export declare class Attribute {
+    key: string | number;
+    hashcode: string;
+    highlight: Profile<Highlight> | null;
+    content: Profile<Content> | null;
+    dot: Profile<Dot> | null;
+    bar: Profile<Bar> | null;
+    event: EventConfig | null;
+    popover: PopoverConfig | null;
+    customData: any;
+    ranges: DateRange[];
+    hasRanges: boolean;
+    order: number;
+    pinPage: boolean;
+    maxRepeatSpan: number;
+    locale: Locale;
+    constructor(config: Partial<AttributeConfig>, theme: Theme, locale: Locale);
+    intersectsRange({ start, end }: DateRange): boolean;
+}

package/dist/types/utils/cache.d.ts

@@ -0,0 +1,10 @@
+export default class Cache<T> {
+    size: number;
+    createKey: (...args: any[]) => string;
+    createItem: (...args: any[]) => T;
+    keys: string[];
+    store: Record<string, T>;
+    constructor(size: number, createKey: (...args: any[]) => string, createItem: (...args: any[]) => T);
+    get(...args: any[]): T;
+    getOrSet(...args: any[]): T;
+}

package/dist/types/utils/calendar/event.d.ts

@@ -0,0 +1,111 @@
+import { type ComputedRef } from 'vue';
+import type { DragOffset, ResizeOffset } from '../../use/calendarGrid';
+import { DateRange } from '../date/range';
+import Locale from '../locale';
+import type { CalendarDay } from '../page';
+import type { PopoverOptions } from '../popovers';
+export interface ResizeOrigin {
+    start: Date;
+    end: Date;
+    isStart: boolean;
+}
+export interface DragOrigin {
+    day: CalendarDay;
+    start: Date;
+    end: Date;
+    minOffsetWeeks: number;
+    maxOffsetWeeks: number;
+    minOffsetWeekdays: number;
+    maxOffsetWeekdays: number;
+    minOffsetMs: number;
+    maxOffsetMs: number;
+    durationMs: number;
+}
+export interface EventConfig {
+    key: PropertyKey;
+    summary: string;
+    description: string;
+    start: Date;
+    end: Date;
+    range: DateRange;
+    allDay: boolean;
+    color: string;
+    selected: boolean;
+}
+export interface EventState {
+    key: any;
+    summary: string;
+    description: string;
+    range: DateRange;
+    allDay: boolean;
+    color: string;
+    fill: string;
+    selected: boolean;
+    draggable: boolean;
+    dragging: boolean;
+    resizable: boolean;
+    resizing: boolean;
+    editing: boolean;
+    order: number;
+    snapMinutes: number;
+    minDurationMinutes: number;
+    maxDurationMinutes: number;
+    popover: Partial<PopoverOptions> | null;
+    resizeOrigin: ResizeOrigin | null;
+    dragOrigin: DragOrigin | null;
+}
+export interface EventContext {
+    days: ComputedRef<CalendarDay[]>;
+    dayRows: ComputedRef<number>;
+    dayColumns: ComputedRef<number>;
+    isDaily: ComputedRef<boolean>;
+    isMonthly: ComputedRef<boolean>;
+    locale: ComputedRef<Locale>;
+}
+export type Event = ReturnType<typeof createEvent>;
+export declare function createEvent(config: Partial<EventConfig>, ctx: EventContext): {
+    refSelector: string;
+    isMultiDay: boolean;
+    isWeekly: boolean;
+    durationMs: number;
+    durationMinutes: number;
+    startDate: Date;
+    startDateTime: number;
+    startTimeLabel: string;
+    endDate: Date;
+    endDateTime: number;
+    endTimeLabel: string;
+    timeLabel: string;
+    isSolid: boolean;
+    dragIsDirty: boolean;
+    formatDate: (date: Date, mask: string) => string;
+    formatTime: (date: Date) => string;
+    resizeToConstraints: () => void;
+    startResize: (day: CalendarDay, isStart: boolean) => void;
+    updateResize: (offset: ResizeOffset) => void;
+    stopResize: () => void;
+    startDrag: (day: CalendarDay) => void;
+    updateDrag: (offset: DragOffset) => void;
+    stopDrag: () => false | undefined;
+    compareTo: (b: Event) => number;
+    key: any;
+    summary: string;
+    description: string;
+    range: DateRange;
+    allDay: boolean;
+    color: string;
+    fill: string;
+    selected: boolean;
+    draggable: boolean;
+    dragging: boolean;
+    resizable: boolean;
+    resizing: boolean;
+    editing: boolean;
+    order: number;
+    snapMinutes: number;
+    minDurationMinutes: number;
+    maxDurationMinutes: number;
+    popover: Partial<PopoverOptions> | null;
+    resizeOrigin: ResizeOrigin | null;
+    dragOrigin: DragOrigin | null;
+};

package/dist/types/utils/config/index.d.ts

@@ -0,0 +1,5 @@
+import type { App as Application } from 'vue';
+declare const config: {};
+export { config as default };
+export declare let VueInstance: Application;
+export declare const setVueInstance: (instance: Application) => void;

package/dist/types/utils/date/helpers.d.ts

@@ -0,0 +1,161 @@
+import { addDays, addMonths, addYears } from 'date-fns';
+import { type LocaleConfig, default as Locale } from '../locale';
+export { addDays, addMonths, addYears };
+export { DateRepeat } from './repeat';
+type DayNameLength = 'narrow' | 'short' | 'long';
+type MonthNameLength = 'short' | 'long';
+export type DayInMonth = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | -1 | -2 | -3 | -4 | -5 | -6 | -7 | -8 | -9 | -10 | -11 | -12 | -13 | -14 | -15 | -16 | -17 | -18 | -19 | -20 | -21 | -22 | -23 | -24 | -25 | -26 | -27 | -28 | -29 | -30 | -31;
+export type DayOfWeek = 1 | 2 | 3 | 4 | 5 | 6 | 7;
+export type WeekInMonth = 1 | 2 | 3 | 4 | 5 | 6;
+export type WeekInMonthFromEnd = -6 | -5 | -4 | -3 | -2 | -1;
+export type OrdinalWeekInMonth = -5 | -4 | -3 | -2 | -1 | 1 | 2 | 3 | 4 | 5;
+export type MonthInYear = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+export type StartOfWeek = 1 | 2 | 3 | 4 | 5 | 6 | 7;
+export type WeekStartsOn = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+export type DateSource = Date | string | number;
+export type TimeNames = Partial<Record<Intl.RelativeTimeFormatUnit, string>>;
+export declare function isDayInMonth(dayInMonth: unknown): dayInMonth is DayInMonth;
+export declare function isDayOfWeek(dayOfWeek: unknown): dayOfWeek is DayOfWeek;
+export declare function isWeekInMonth(weekInMonth: unknown): weekInMonth is WeekInMonth;
+export declare function isMonthInYear(monthInYear: unknown): monthInYear is MonthInYear;
+export declare function isOrdinalWeekInMonth(weekInMonth: unknown): weekInMonth is OrdinalWeekInMonth;
+interface NumberRuleConfig {
+    min?: number;
+    max?: number;
+    interval?: number;
+}
+type DatePartsRuleFunction = (part: number, parts: TimeParts) => boolean;
+type DatePartsRule = number | Array<number> | NumberRuleConfig | DatePartsRuleFunction;
+export interface DatePartsRules {
+    hours?: DatePartsRule;
+    minutes?: DatePartsRule;
+    seconds?: DatePartsRule;
+    milliseconds?: DatePartsRule;
+}
+export interface DatePartOption {
+    value: number;
+    label: string;
+    disabled?: boolean;
+}
+export interface FormatParseOptions {
+    locale?: Locale | LocaleConfig | string;
+    timezone?: string;
+}
+export interface DateOptions {
+    type: string;
+    fillDate: DateSource;
+    mask: string;
+    patch: DatePatch;
+    rules: DatePartsRules;
+}
+export interface PageAddress {
+    day?: number;
+    week?: number;
+    month: number;
+    year: number;
+}
+export interface TimeParts {
+    hours: number;
+    minutes: number;
+    seconds: number;
+    milliseconds: number;
+}
+export interface SimpleDateParts {
+    year: number;
+    month: number;
+    day: number;
+    hours: number;
+    minutes: number;
+    seconds: number;
+    milliseconds: number;
+}
+export interface DayParts {
+    dayIndex: number;
+    day: number;
+    dayFromEnd: number;
+    weekday: number;
+    weekdayOrdinal: number;
+    weekdayOrdinalFromEnd: number;
+    week: number;
+    weekFromEnd: number;
+    weeknumber: number;
+    month: number;
+    year: number;
+    date: Date;
+}
+export interface DateParts extends DayParts {
+    milliseconds: number;
+    seconds: number;
+    minutes: number;
+    hours: number;
+    time: number;
+    dateTime: number;
+    isValid: boolean;
+    timezoneOffset: number;
+    isPm?: boolean;
+}
+export interface MonthParts {
+    firstDayOfWeek: DayOfWeek;
+    firstDayOfMonth: Date;
+    inLeapYear: boolean;
+    firstWeekday: number;
+    numDays: number;
+    numWeeks: number;
+    month: number;
+    year: number;
+    weeknumbers: number[];
+    isoWeeknumbers: number[];
+}
+export type DatePatch = 'dateTime' | 'date' | 'time';
+export declare const DatePatchKeys: Record<DatePatch, (keyof SimpleDateParts)[]>;
+export declare const daysInWeek = 7;
+export declare const weeksInMonth = 6;
+export declare const MS_PER_SECOND = 1000;
+export declare const MS_PER_MINUTE: number;
+export declare const MS_PER_HOUR: number;
+export declare const MS_PER_DAY: number;
+type DatePartsRange = Readonly<[number, number, number]>;
+export declare function isDateParts(parts: unknown): parts is Partial<DateParts>;
+export declare function isDateSource(date: unknown): date is DateSource;
+export declare function roundDate(dateMs: number, snapMs?: number): Date;
+export declare function startOfWeek(date: Date, firstDayOfWeek?: DayOfWeek): Date;
+export declare function getStartOfWeek(date: Date, firstDayOfWeek?: DayOfWeek): Date;
+export declare function getDayIndex(year: number, month: number, day: number): number;
+export declare function diffInDays(d1: Date, d2: Date): number;
+export declare function diffInWeeks(d1: Date, d2: Date): number;
+export declare function diffInYears(d1: Date, d2: Date): number;
+export declare function diffInMonths(d1: Date, d2: Date): number;
+export declare function getDateFromParts(parts: Partial<SimpleDateParts>, timezone?: string): Date;
+export declare function getTimezoneOffset(parts: Partial<SimpleDateParts>, timezone?: string): number;
+export declare function getDateParts(date: Date, locale: Locale, timezone?: string | undefined): DateParts;
+export declare function getMonthPartsKey(month: number, year: number, firstDayOfWeek: DayOfWeek): string;
+export declare function getMonthParts(month: number, year: number, firstDayOfWeek: DayOfWeek): {
+    firstDayOfWeek: DayOfWeek;
+    firstDayOfMonth: Date;
+    inLeapYear: boolean;
+    firstWeekday: number;
+    numDays: number;
+    numWeeks: number;
+    month: number;
+    year: number;
+    weeknumbers: number[];
+    isoWeeknumbers: number[];
+};
+export declare function getWeekdayDates(): Date[];
+export declare function getDayNames(length: DayNameLength, localeId?: string | undefined): string[];
+export declare function getHourDates(): Date[];
+export declare function getRelativeTimeNames(localeId?: undefined): TimeNames;
+export declare function getMonthDates(): Date[];
+export declare function getMonthNames(length: MonthNameLength, localeId?: undefined): string[];
+export declare function datePartIsValid(part: number, rule: DatePartsRule, parts: DateParts): boolean;
+export declare function getDatePartOptions(parts: DateParts, range: DatePartsRange, rule: DatePartsRule | undefined): DatePartOption[];
+export declare function getDatePartsOptions(parts: DateParts, rules: DatePartsRules): {
+    milliseconds: DatePartOption[];
+    seconds: DatePartOption[];
+    minutes: DatePartOption[];
+    hours: DatePartOption[];
+};
+export declare function getNearestDatePart(parts: DateParts, range: DatePartsRange, value: number, rule: DatePartsRule): number;
+export declare function applyRulesForDateParts(dateParts: DateParts, rules: DatePartsRules): DateParts;
+export declare function parseDate(dateString: string, mask: string | string[], locale: Locale): Date;
+export declare function formatDate(date: Date, masks: string | string[], locale: Locale): string;

package/dist/types/utils/date/range.d.ts

@@ -0,0 +1,74 @@
+import Locale from '../locale';
+import type { CalendarDay } from '../page';
+import { type DateParts, type DayParts } from './helpers';
+import { DateRepeat, type DateRepeatConfig } from './repeat';
+type DateRangeDate = Date | string | number | null;
+interface DateRangeConfig {
+    start: DateRangeDate;
+    end: DateRangeDate;
+    span: number;
+    order: number;
+    repeat: Partial<DateRepeatConfig>;
+}
+export type DateRangeSource = DateRange | DateRangeDate | [DateRangeDate, DateRangeDate] | Partial<DateRangeConfig>;
+export interface SimpleDateRange {
+    start: Date;
+    end: Date;
+}
+export declare class DateRange {
+    order: number;
+    locale: Locale;
+    start: DateParts | null;
+    end: DateParts | null;
+    repeat: DateRepeat | null;
+    static fromMany(ranges: DateRangeSource | DateRangeSource[], locale: Locale): DateRange[];
+    static from(source: DateRangeSource, locale: Locale): DateRange;
+    private constructor();
+    get opts(): {
+        order: number;
+        locale: Locale;
+    };
+    get hasRepeat(): boolean;
+    get isSingleDay(): boolean | null;
+    get isMultiDay(): boolean;
+    get daySpan(): number;
+    startsOnDay(dayParts: DayParts): boolean;
+    intersectsDay(dayIndex: number): boolean;
+    intersectsRange(range: DateRange): boolean;
+    intersectsDayRange(startDayIndex: number, endDayIndex: number): boolean;
+}
+interface DataRange {
+    startDay: number;
+    startTime: number;
+    endDay: number;
+    endTime: number;
+}
+export interface RangeData {
+    key: string | number;
+    order?: number;
+}
+export interface DateRangeCell<T extends RangeData> extends DataRange {
+    data: T;
+    onStart: boolean;
+    onEnd: boolean;
+    startTime: number;
+    startDate: Date;
+    endTime: number;
+    endDate: Date;
+    allDay: boolean;
+    order: number;
+}
+export declare class DateRangeContext {
+    private records;
+    render(data: RangeData, range: DateRange, days: DayParts[]): {
+        startDay: number;
+        startTime: number;
+        endDay: number;
+        endTime: number;
+    } | null;
+    private getRangeRecords;
+    getCell(key: string | number, day: CalendarDay): DateRangeCell<any> | undefined;
+    cellExists(key: string | number, dayIndex: number): boolean;
+    getCells(day: CalendarDay): DateRangeCell<any>[];
+}
+export {};

package/dist/types/utils/date/repeat.d.ts

@@ -0,0 +1,34 @@
+import Locale from '../locale';
+import type { DateParts, DayInMonth, DayOfWeek, DayParts, MonthInYear, WeekInMonth } from './helpers';
+import { GroupRuleType, type Rule, type RuleType, type SingleOrArray } from './rules';
+export type RepeatIntervalShort = 'day' | 'week' | 'month' | 'year';
+export type RepeatInterval = 'days' | 'weeks' | 'months' | 'years';
+export interface DateRepeatConfig {
+    every: RepeatIntervalShort | [number, RepeatInterval];
+    from: Date;
+    until: Date;
+    weekdays: SingleOrArray<DayOfWeek>;
+    days: SingleOrArray<DayInMonth>;
+    weeks: SingleOrArray<WeekInMonth>;
+    months: SingleOrArray<MonthInYear>;
+    years: SingleOrArray<number>;
+    ordinalWeekdays: SingleOrArray<number[]>;
+    on: SingleOrArray<DateRepeatFn | Partial<DateRepeatConfig>>;
+}
+export type DateRepeatFn = (dayParts: DayParts) => boolean;
+export interface DateRepeatOptions {
+    locale: Locale;
+}
+export declare class DateRepeat implements Rule<GroupRuleType> {
+    private parent?;
+    validated: boolean;
+    config: Partial<DateRepeatConfig> | DateRepeatFn;
+    type: GroupRuleType;
+    from: DateParts | undefined;
+    until: DateParts | undefined;
+    rules: Rule<RuleType>[];
+    locale: Locale;
+    constructor(config: Partial<DateRepeatConfig> | DateRepeatFn, options?: Partial<DateRepeatOptions>, parent?: DateRepeat | undefined);
+    getObjectRules(config: any): Rule<RuleType>[];
+    passes(dayParts: DayParts): boolean;
+}

package/dist/types/utils/date/rules.d.ts

@@ -0,0 +1,82 @@
+import { type DayOfWeek, type DayParts, type OrdinalWeekInMonth } from './helpers';
+export type SingleOrArray<T> = T | T[];
+export declare enum GroupRuleType {
+    Any = "any",
+    All = "all"
+}
+export declare enum IntervalRuleType {
+    Days = "days",
+    Weeks = "weeks",
+    Months = "months",
+    Years = "years"
+}
+export declare enum ComponentRuleType {
+    Days = "days",
+    Weekdays = "weekdays",
+    Weeks = "weeks",
+    Months = "months",
+    Years = "years"
+}
+export declare enum OrdinalComponentRuleType {
+    OrdinalWeekdays = "ordinalWeekdays"
+}
+export declare enum FunctionRuleType {
+    Function = "function"
+}
+export type RuleType = GroupRuleType | IntervalRuleType | ComponentRuleType | OrdinalComponentRuleType | FunctionRuleType;
+export type OrdinalArrayConfig = SingleOrArray<[
+    OrdinalWeekInMonth,
+    ...DayOfWeek[]
+]>;
+export interface Rule<T> {
+    type: T;
+    passes(dayParts: DayParts): boolean;
+}
+export declare class IntervalRule implements Rule<IntervalRuleType> {
+    type: IntervalRuleType;
+    interval: number;
+    from: DayParts;
+    private validated;
+    constructor(type: IntervalRuleType, interval: number, from: DayParts);
+    passes(dateParts: DayParts): boolean;
+}
+export declare class ComponentRule implements Rule<ComponentRuleType> {
+    type: ComponentRuleType;
+    validator: (component: unknown) => component is number;
+    getter: (dayParts: DayParts) => number[];
+    components: number[];
+    static create(type: ComponentRuleType, config: unknown): DaysRule | WeekdaysRule | WeeksRule | MonthsRule | YearsRule;
+    constructor(type: ComponentRuleType, components: unknown, validator: (component: unknown) => component is number, getter: (dayParts: DayParts) => number[]);
+    normalizeComponents(components: unknown): number[];
+    passes(dayParts: DayParts): boolean;
+}
+export declare class DaysRule extends ComponentRule {
+    constructor(components: unknown);
+}
+export declare class WeekdaysRule extends ComponentRule {
+    constructor(components: unknown);
+}
+export declare class WeeksRule extends ComponentRule {
+    constructor(components: unknown);
+}
+export declare class MonthsRule extends ComponentRule {
+    constructor(components: unknown);
+}
+export declare class YearsRule extends ComponentRule {
+    constructor(components: unknown);
+}
+export declare class OrdinalComponentRule implements Rule<OrdinalComponentRuleType> {
+    type: OrdinalComponentRuleType;
+    components: [OrdinalWeekInMonth, DayOfWeek][];
+    constructor(type: OrdinalComponentRuleType, components: OrdinalArrayConfig);
+    normalizeArrayConfig(config: OrdinalArrayConfig): [OrdinalWeekInMonth, DayOfWeek][];
+    normalizeComponents(config: OrdinalArrayConfig): [OrdinalWeekInMonth, DayOfWeek][];
+    passes(dayParts: DayParts): boolean;
+}
+export declare class FunctionRule implements Rule<FunctionRuleType> {
+    fn: Function;
+    type: FunctionRuleType;
+    private validated;
+    constructor(fn: Function);
+    passes(dayParts: DayParts): any;
+}

package/dist/types/utils/defaults/index.d.ts

@@ -0,0 +1,30 @@
+import { type App } from 'vue';
+import type { DarkModeConfig } from '../useDisplayMode';
+interface DatePickerPopoverDefaults {
+    visibility?: string;
+    placement?: string;
+    isInteractive?: boolean;
+}
+interface DatePickerDefaults {
+    updateOnInput?: boolean;
+    inputDebounce?: number;
+    popover?: DatePickerPopoverDefaults;
+}
+export interface Defaults {
+    componentPrefix?: string;
+    color?: string;
+    isDark?: DarkModeConfig;
+    navVisibility?: string;
+    titlePosition?: string;
+    transition?: string;
+    touch?: object;
+    masks?: object;
+    locales?: any;
+    datePicker?: DatePickerDefaults;
+}
+declare const defaultLocales: import("vue").ComputedRef<{
+    [x: string]: any;
+}>;
+export { defaultLocales };
+export declare const getDefault: (path: string) => any;
+export declare const setupDefaults: (app: App, userDefaults: Defaults | undefined) => any;

package/dist/types/utils/defaults/locales.d.ts

@@ -0,0 +1,9 @@
+interface LocaleSetting {
+    id: string;
+    firstDayOfWeek: number;
+    masks: {
+        L: string;
+    };
+}
+declare const localeSettings: Record<string, LocaleSetting>;
+export default localeSettings;

package/dist/types/utils/glyph.d.ts

@@ -0,0 +1,58 @@
+import { Attribute } from './attribute';
+import type { DateRangeCell } from './date/range';
+export interface Glyph {
+    key: string | number;
+    color: string;
+    class: string | any[];
+    style: Record<string, any>;
+}
+export interface Profile<T> {
+    start: T;
+    base: T;
+    end: T;
+    startEnd?: T;
+}
+export type HighlightFillMode = 'solid' | 'light' | 'outline';
+export interface Highlight extends Glyph {
+    fillMode: HighlightFillMode;
+    wrapperClass: string | any[];
+    contentClass: string | any[];
+    contentStyle: Record<string, any>;
+}
+export type HighlightConfig = boolean | string | Partial<Highlight | Profile<Partial<Highlight>>>;
+export type Dot = Glyph;
+export type DotConfig = boolean | string | Partial<Dot | Profile<Partial<Dot>>>;
+export type Bar = Glyph;
+export type BarConfig = boolean | string | Partial<Bar | Profile<Partial<Bar>>>;
+export type Content = Glyph;
+export type ContentConfig = string | Partial<Content | Profile<Partial<Content>>>;
+export interface GlyphRenderer<P extends Partial<Glyph>> {
+    type: string;
+    normalizeConfig(color: string, config: any): Profile<P>;
+    prepareRender(glyphs: Record<string, P[]>): void;
+    render(attr: DateRangeCell<Attribute>, glyphs: Record<string, P[]>): void;
+}
+export declare class HighlightRenderer implements GlyphRenderer<Highlight> {
+    type: string;
+    normalizeConfig(color: string, config: any): Profile<Highlight>;
+    prepareRender(glyphs: Record<string, Glyph[]>): void;
+    render({ data, onStart, onEnd }: DateRangeCell<Attribute>, glyphs: Record<string, Highlight[]>): void;
+}
+export declare class BaseRenderer<T extends Partial<Glyph>> implements GlyphRenderer<T> {
+    type: string;
+    collectionType: string;
+    constructor(type: string, collectionType: string);
+    normalizeConfig(color: string, config: any): Profile<T>;
+    prepareRender(glyphs: Record<string, T[]>): void;
+    render({ data, onStart, onEnd }: DateRangeCell<Attribute>, glyphs: Record<string, T[]>): void;
+}
+export declare class ContentRenderer extends BaseRenderer<Content> {
+    constructor();
+    normalizeConfig(_: string, config: any): Profile<Content>;
+}
+export declare class DotRenderer extends BaseRenderer<Dot> {
+    constructor();
+}
+export declare class BarRenderer extends BaseRenderer<Dot> {
+    constructor();
+}

package/dist/types/utils/helpers.d.ts

@@ -0,0 +1,49 @@
+import isFunction from 'lodash/isFunction';
+import isString from 'lodash/isString';
+export { isFunction, isString };
+export { default as isBoolean } from 'lodash/isBoolean';
+export { default as isNumber } from 'lodash/isNumber';
+export { default as isUndefined } from 'lodash/isUndefined';
+export { default as get } from 'lodash/get';
+export { default as set } from 'lodash/set';
+export { default as mapValues } from 'lodash/mapValues';
+export { default as defaults } from 'lodash/defaults';
+export { default as defaultsDeep } from 'lodash/defaultsDeep';
+export { default as map } from 'lodash/map';
+export { default as head } from 'lodash/head';
+export { default as last } from 'lodash/last';
+export declare const getType: (value: any) => string;
+export declare const isDate: (value: unknown) => value is Date;
+export declare const isObject: (value: unknown) => value is object;
+declare const hasObj: any;
+export { hasObj as has };
+export declare const hasAny: (obj: object, props: string[]) => boolean;
+export declare const some: {
+    <T>(collection: import("lodash").List<T> | null | undefined, predicate?: import("lodash").ListIterateeCustom<T, boolean>): boolean;
+    <T extends object>(collection: T | null | undefined, predicate?: import("lodash").ObjectIterateeCustom<T, boolean>): boolean;
+};
+export declare const pad: (val: string | number, len: number, char?: string) => string;
+export declare const roundTenth: (n: number) => number;
+export declare const isArray: (val: any) => val is any[];
+export declare const arrayHasItems: (array: any) => boolean;
+export declare const resolveEl: (target: unknown) => Node | null;
+export declare const resolveDocument: (target?: unknown) => Document | null;
+export interface ElementPosition {
+    top: number;
+    left: number;
+}
+export interface CustomElement {
+    addEventListener: Function;
+    removeEventListener: Function;
+    dispatchEvent: Function;
+}
+export declare const off: (element: CustomElement, event: string, handler: (e: any) => void, opts?: boolean | EventListenerOptions | undefined) => void;
+export declare const on: (element: CustomElement, event: string, handler: (e: any) => void, opts?: boolean | AddEventListenerOptions | undefined) => () => void;
+export declare const elementContains: (element: Node, child: Node) => boolean;
+export declare const onSpaceOrEnter: (event: KeyboardEvent, handler: (e: KeyboardEvent) => void) => void;
+export declare const capitalize: (str: string) => string;
+export declare const omit: <T extends object, K extends [...(keyof T)[]]>(obj: T, ...keys: K) => { [K_1 in keyof T]: T[K_1]; };
+export declare const pick: <T extends object, K extends keyof T>(obj: T, keys: K[]) => Pick<T, K>;
+export declare function extend<T extends object, E extends object>(value: T, ext: E): T & E;
+export declare function clamp(num: number, min: number, max: number): number;
+export declare function hash(str: string): number;