@seniorsistemas/angular-components 19.7.4 → 19.7.6

package/esm2022/datepicker/lib/datepicker/date-segment-input.mjs

@@ -0,0 +1,418 @@
+const DATE_FORMAT_TOKEN_RE = /yyyy|yy|MM|mm|dd|d/g;
+const YEAR_SEGMENT_LENGTH = 4;
+const SHORT_SEGMENT_LENGTH = 2;
+const HOURS_PER_MERIDIEM = 12;
+const MAX_HOUR_24 = 23;
+const MAX_MINUTE_SECOND = 59;
+const GENERIC_MAX_DAY = 31;
+const LEAP_REFERENCE_YEAR = 2000;
+function isEditableSegment(segment) {
+    return segment.kind !== 'literal';
+}
+/** Tokeniza um `dateFormat` (ex.: `dd/MM/yyyy`, `MM/dd/yy`) em tokens de dia/mês/ano + literais. */
+export function tokenizeDateFormat(format) {
+    const tokens = [];
+    let lastIndex = 0;
+    DATE_FORMAT_TOKEN_RE.lastIndex = 0;
+    let match;
+    while ((match = DATE_FORMAT_TOKEN_RE.exec(format))) {
+        if (match.index > lastIndex) {
+            tokens.push({ kind: 'literal', raw: format.slice(lastIndex, match.index) });
+        }
+        const raw = match[0];
+        const kind = raw[0] === 'y' ? 'year' : raw[0] === 'd' ? 'day' : 'month';
+        tokens.push({ kind, raw });
+        lastIndex = DATE_FORMAT_TOKEN_RE.lastIndex;
+    }
+    if (lastIndex < format.length) {
+        tokens.push({ kind: 'literal', raw: format.slice(lastIndex) });
+    }
+    return tokens;
+}
+/** Dias no mês (1-12), já resolvendo fevereiro/ano bissexto via rollover nativo do `Date`. */
+export function daysInMonth(month, year) {
+    return new Date(year, month, 0).getDate();
+}
+function buildDateSegments(dateFormat) {
+    return tokenizeDateFormat(dateFormat).map((token) => {
+        if (token.kind === 'literal')
+            return { kind: 'literal', text: token.raw };
+        if (token.kind === 'year')
+            return { kind: 'year', length: YEAR_SEGMENT_LENGTH, text: '' };
+        if (token.kind === 'month')
+            return { kind: 'month', length: SHORT_SEGMENT_LENGTH, text: '' };
+        return { kind: 'day', length: SHORT_SEGMENT_LENGTH, text: '' };
+    });
+}
+function buildMonthSegments(dateFormat) {
+    const all = buildDateSegments(dateFormat);
+    const dayIdx = all.findIndex((s) => s.kind === 'day');
+    if (dayIdx === -1)
+        return all;
+    const dropIndexes = new Set([dayIdx]);
+    if (all[dayIdx + 1]?.kind === 'literal') {
+        dropIndexes.add(dayIdx + 1);
+    }
+    else if (all[dayIdx - 1]?.kind === 'literal') {
+        dropIndexes.add(dayIdx - 1);
+    }
+    return all.filter((_, i) => !dropIndexes.has(i));
+}
+function buildTimeSegments(hourFormat, showSeconds) {
+    const segments = [
+        { kind: 'hour', length: SHORT_SEGMENT_LENGTH, text: '' },
+        { kind: 'literal', text: ':' },
+        { kind: 'minute', length: SHORT_SEGMENT_LENGTH, text: '' },
+    ];
+    if (showSeconds) {
+        segments.push({ kind: 'literal', text: ':' }, { kind: 'second', length: SHORT_SEGMENT_LENGTH, text: '' });
+    }
+    if (hourFormat === '12') {
+        segments.push({ kind: 'literal', text: ' ' }, { kind: 'ampm', length: SHORT_SEGMENT_LENGTH, text: '' });
+    }
+    return segments;
+}
+function buildSegmentsFor(config) {
+    switch (config.mode) {
+        case 'date':
+            return buildDateSegments(config.dateFormat);
+        case 'month':
+            return buildMonthSegments(config.dateFormat);
+        case 'time':
+            return buildTimeSegments(config.hourFormat, config.showSeconds);
+        case 'datetime':
+            return [
+                ...buildDateSegments(config.dateFormat),
+                { kind: 'literal', text: ' ' },
+                ...buildTimeSegments(config.hourFormat, config.showSeconds),
+            ];
+    }
+}
+/**
+ * Engine de segmentos (dia/mês/ano/hora/minuto/segundo/ampm) para o trigger do datepicker.
+ * Sem dependências de Angular — DOM/CVA ficam por conta do componente que a consome.
+ */
+export class DateSegmentEngine {
+    segments = [];
+    config = null;
+    activeIndex = null;
+    freshEntry = true;
+    configure(config) {
+        this.config = config;
+        this.segments = buildSegmentsFor(config);
+        this.activeIndex = null;
+        this.freshEntry = true;
+    }
+    getDisplayString() {
+        return this.segments.map((s) => (isEditableSegment(s) ? this.renderSegment(s) : s.text)).join('');
+    }
+    renderSegment(segment) {
+        return segment.text + '_'.repeat(Math.max(0, segment.length - segment.text.length));
+    }
+    segmentRenderLength(segment) {
+        return isEditableSegment(segment) ? segment.length : segment.text.length;
+    }
+    getSegmentRange(index) {
+        let start = 0;
+        for (let i = 0; i < index; i++) {
+            start += this.segmentRenderLength(this.segments[i]);
+        }
+        return [start, start + this.segmentRenderLength(this.segments[index])];
+    }
+    getFirstEditableIndex() {
+        return this.segments.findIndex((s) => isEditableSegment(s));
+    }
+    getLastEditableIndex() {
+        for (let i = this.segments.length - 1; i >= 0; i--) {
+            if (isEditableSegment(this.segments[i]))
+                return i;
+        }
+        return -1;
+    }
+    getActiveIndex() {
+        return this.activeIndex;
+    }
+    activeKind() {
+        if (this.activeIndex === null)
+            return null;
+        const segment = this.segments[this.activeIndex];
+        return isEditableSegment(segment) ? segment.kind : null;
+    }
+    selectSegmentAt(charIndex) {
+        let acc = 0;
+        for (let i = 0; i < this.segments.length; i++) {
+            const len = this.segmentRenderLength(this.segments[i]);
+            if (charIndex < acc + len) {
+                return this.nearestEditableFrom(i);
+            }
+            acc += len;
+        }
+        return this.getLastEditableIndex();
+    }
+    nearestEditableFrom(index) {
+        for (let i = index; i < this.segments.length; i++) {
+            if (isEditableSegment(this.segments[i]))
+                return i;
+        }
+        return this.getLastEditableIndex();
+    }
+    selectSegment(index) {
+        if (index < 0 || index >= this.segments.length || !isEditableSegment(this.segments[index]))
+            return;
+        this.activeIndex = index;
+        this.freshEntry = true;
+    }
+    selectFirstSegment() {
+        this.selectSegment(this.getFirstEditableIndex());
+    }
+    /** Commita (pad/clamp) o segmento ativo e move para o próximo/anterior editável. */
+    moveToAdjacentSegment(direction) {
+        this.commitActiveSegment();
+        if (this.activeIndex === null)
+            return 'boundary';
+        let next = this.activeIndex;
+        do {
+            next += direction;
+        } while (next >= 0 && next < this.segments.length && !isEditableSegment(this.segments[next]));
+        if (next < 0 || next >= this.segments.length) {
+            this.activeIndex = null;
+            return 'boundary';
+        }
+        this.selectSegment(next);
+        return 'moved';
+    }
+    typeDigit(digit) {
+        if (this.activeIndex === null)
+            return;
+        const segment = this.segments[this.activeIndex];
+        if (!isEditableSegment(segment) || segment.kind === 'ampm')
+            return;
+        if (this.freshEntry) {
+            segment.text = '';
+            this.freshEntry = false;
+        }
+        if (segment.text.length >= segment.length)
+            return;
+        segment.text += digit;
+        if (segment.text.length >= segment.length) {
+            this.commitActiveSegment();
+            this.autoAdvance();
+        }
+    }
+    autoAdvance() {
+        if (this.activeIndex === null)
+            return;
+        let next = this.activeIndex;
+        do {
+            next += 1;
+        } while (next < this.segments.length && !isEditableSegment(this.segments[next]));
+        if (next < this.segments.length) {
+            this.selectSegment(next);
+        }
+    }
+    setAmPm(value) {
+        if (this.activeIndex === null)
+            return;
+        const segment = this.segments[this.activeIndex];
+        if (!isEditableSegment(segment) || segment.kind !== 'ampm')
+            return;
+        segment.text = value === 1 ? 'PM' : 'AM';
+        this.freshEntry = true;
+    }
+    clearActiveSegment(kind) {
+        if (this.activeIndex === null)
+            return;
+        const segment = this.segments[this.activeIndex];
+        if (!isEditableSegment(segment))
+            return;
+        if (segment.text === '') {
+            if (kind === 'backspace') {
+                let prev = this.activeIndex;
+                do {
+                    prev -= 1;
+                } while (prev >= 0 && !isEditableSegment(this.segments[prev]));
+                if (prev >= 0) {
+                    this.activeIndex = prev;
+                    this.freshEntry = false;
+                }
+            }
+            return;
+        }
+        segment.text = '';
+        this.freshEntry = true;
+    }
+    /** Limpa todos os segmentos editáveis (usado quando o campo inteiro está selecionado, ex.: Ctrl+A). */
+    clearAll() {
+        for (const segment of this.segments) {
+            if (isEditableSegment(segment))
+                segment.text = '';
+        }
+        this.activeIndex = this.getFirstEditableIndex();
+        this.freshEntry = true;
+    }
+    /** Incrementa/decrementa o segmento ativo, dando a volta (wrap) dentro do range válido. */
+    incrementActiveSegment(delta) {
+        if (this.activeIndex === null)
+            return;
+        const segment = this.segments[this.activeIndex];
+        if (!isEditableSegment(segment))
+            return;
+        if (segment.kind === 'ampm') {
+            this.setAmPm(segment.text === 'PM' ? 0 : 1);
+            return;
+        }
+        const { min, max } = this.boundsFor(segment.kind);
+        const range = max - min + 1;
+        const current = segment.text ? parseInt(segment.text, 10) : delta > 0 ? min - 1 : min;
+        const next = (((current + delta - min) % range) + range) % range + min;
+        segment.text = String(next).padStart(segment.length, '0');
+        this.freshEntry = true;
+        this.reconcileDayIfNeeded(segment.kind);
+    }
+    /** Pad/clamp do segmento ativo (ex.: "2" -> "02", "45" no dia -> clamp para daysInMonth). */
+    commitActiveSegment() {
+        if (this.activeIndex === null)
+            return;
+        const segment = this.segments[this.activeIndex];
+        if (!isEditableSegment(segment))
+            return;
+        const kind = segment.kind;
+        segment.text = this.clampAndPad(segment);
+        this.freshEntry = true;
+        this.reconcileDayIfNeeded(kind);
+    }
+    /** Commita o segmento ativo e sai do modo de edição (usado no blur do campo). */
+    deactivate() {
+        this.commitActiveSegment();
+        this.activeIndex = null;
+    }
+    clampAndPad(segment) {
+        if (segment.kind === 'ampm' || segment.kind === 'year' || !segment.text) {
+            return segment.text;
+        }
+        const num = parseInt(segment.text, 10);
+        const { min, max } = this.boundsFor(segment.kind);
+        const clamped = Math.min(max, Math.max(min, num));
+        return String(clamped).padStart(segment.length, '0');
+    }
+    boundsFor(kind) {
+        switch (kind) {
+            case 'day':
+                return { min: 1, max: this.daysInMonthNow() };
+            case 'month':
+                return { min: 1, max: HOURS_PER_MERIDIEM };
+            case 'hour':
+                return this.config?.hourFormat === '12'
+                    ? { min: 1, max: HOURS_PER_MERIDIEM }
+                    : { min: 0, max: MAX_HOUR_24 };
+            case 'minute':
+            case 'second':
+                return { min: 0, max: MAX_MINUTE_SECOND };
+            default:
+                return { min: 0, max: 9999 };
+        }
+    }
+    /**
+     * Bound do dia dependendo do que já é conhecido de mês/ano. Nunca "adivinha" com o mês/ano
+     * atuais do sistema — isso estreitaria o range antes da hora (ex.: dia=29 digitado antes do
+     * ano, mês=fevereiro conhecido mas ano ainda não -> se assumisse o ano atual do sistema e ele
+     * não fosse bissexto, o dia seria clampado para 28 e nunca mais reexpandido para 29 mesmo que
+     * o ano realmente digitado depois seja bissexto). Em vez disso, fica sempre no lado permissivo
+     * até que a informação realmente exista.
+     */
+    daysInMonthNow() {
+        const monthSegment = this.findEditable('month');
+        const monthKnown = !!monthSegment?.text && monthSegment.text.length === monthSegment.length;
+        if (!monthSegment || !monthKnown)
+            return GENERIC_MAX_DAY;
+        const month = parseInt(monthSegment.text, 10);
+        const yearSegment = this.findEditable('year');
+        const yearKnown = !!yearSegment?.text && yearSegment.text.length === YEAR_SEGMENT_LENGTH;
+        if (!yearSegment || !yearKnown)
+            return daysInMonth(month, LEAP_REFERENCE_YEAR);
+        return daysInMonth(month, parseInt(yearSegment.text, 10));
+    }
+    reconcileDayIfNeeded(committedKind) {
+        if (committedKind !== 'month' && committedKind !== 'year')
+            return;
+        const daySegment = this.findEditable('day');
+        if (!daySegment || daySegment.text.length !== daySegment.length)
+            return;
+        const max = this.daysInMonthNow();
+        const dayNum = parseInt(daySegment.text, 10);
+        if (dayNum > max) {
+            daySegment.text = String(max).padStart(daySegment.length, '0');
+        }
+    }
+    findEditable(kind) {
+        return this.segments.find((s) => isEditableSegment(s) && s.kind === kind);
+    }
+    isEmpty() {
+        return this.segments.every((s) => !isEditableSegment(s) || s.text === '');
+    }
+    isComplete() {
+        return this.segments.every((s) => !isEditableSegment(s) || s.text.length === s.length);
+    }
+    loadFromDate(date) {
+        for (const segment of this.segments) {
+            if (isEditableSegment(segment))
+                segment.text = '';
+        }
+        this.activeIndex = null;
+        this.freshEntry = true;
+        if (!date)
+            return;
+        for (const segment of this.segments) {
+            if (!isEditableSegment(segment))
+                continue;
+            segment.text = this.renderValueFor(segment.kind, date);
+        }
+    }
+    renderValueFor(kind, date) {
+        switch (kind) {
+            case 'day':
+                return String(date.getDate()).padStart(SHORT_SEGMENT_LENGTH, '0');
+            case 'month':
+                return String(date.getMonth() + 1).padStart(SHORT_SEGMENT_LENGTH, '0');
+            case 'year':
+                return String(date.getFullYear()).padStart(YEAR_SEGMENT_LENGTH, '0');
+            case 'hour': {
+                const h = date.getHours();
+                const display = this.config?.hourFormat === '12' ? (h % HOURS_PER_MERIDIEM === 0 ? HOURS_PER_MERIDIEM : h % HOURS_PER_MERIDIEM) : h;
+                return String(display).padStart(SHORT_SEGMENT_LENGTH, '0');
+            }
+            case 'minute':
+                return String(date.getMinutes()).padStart(SHORT_SEGMENT_LENGTH, '0');
+            case 'second':
+                return String(date.getSeconds()).padStart(SHORT_SEGMENT_LENGTH, '0');
+            case 'ampm':
+                return date.getHours() < HOURS_PER_MERIDIEM ? 'AM' : 'PM';
+        }
+    }
+    /** Constrói o `Date` a partir dos segmentos; `null` enquanto incompleto. Usa `referenceDate` para preencher partes ausentes (ex.: hora ao editar só a data). */
+    toDate(referenceDate) {
+        if (!this.isComplete())
+            return null;
+        const ref = referenceDate ?? new Date();
+        const getNum = (kind) => {
+            const segment = this.findEditable(kind);
+            return segment ? parseInt(segment.text, 10) : null;
+        };
+        const year = getNum('year') ?? ref.getFullYear();
+        const monthNum = getNum('month');
+        const month = monthNum !== null ? monthNum - 1 : ref.getMonth();
+        const day = this.config?.mode === 'month' ? 1 : (getNum('day') ?? ref.getDate());
+        let hour = getNum('hour');
+        const minute = getNum('minute') ?? ref.getMinutes();
+        const second = getNum('second') ?? ref.getSeconds();
+        if (hour !== null && this.config?.hourFormat === '12') {
+            const ampmSegment = this.findEditable('ampm');
+            const isPm = ampmSegment?.text === 'PM';
+            hour = hour % HOURS_PER_MERIDIEM;
+            if (isPm)
+                hour += HOURS_PER_MERIDIEM;
+        }
+        return new Date(year, month, day, hour ?? ref.getHours(), minute, second);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-segment-input.js","sourceRoot":"","sources":["../../../../../projects/angular-components/datepicker/src/lib/datepicker/date-segment-input.ts"],"names":[],"mappings":"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","sourcesContent":["export type SegmentKind = 'day' | 'month' | 'year' | 'hour' | 'minute' | 'second' | 'ampm';\n\nexport interface EditableSegmentState {\n    kind: SegmentKind;\n    length: number;\n    text: string;\n}\n\nexport interface LiteralSegmentState {\n    kind: 'literal';\n    text: string;\n}\n\nexport type SegmentState = EditableSegmentState | LiteralSegmentState;\n\nexport interface SegmentEngineConfig {\n    mode: 'date' | 'month' | 'time' | 'datetime';\n    dateFormat: string;\n    hourFormat: '12' | '24';\n    showSeconds: boolean;\n}\n\ninterface FormatToken {\n    kind: 'day' | 'month' | 'year' | 'literal';\n    raw: string;\n}\n\nconst DATE_FORMAT_TOKEN_RE = /yyyy|yy|MM|mm|dd|d/g;\nconst YEAR_SEGMENT_LENGTH = 4;\nconst SHORT_SEGMENT_LENGTH = 2;\nconst HOURS_PER_MERIDIEM = 12;\nconst MAX_HOUR_24 = 23;\nconst MAX_MINUTE_SECOND = 59;\nconst GENERIC_MAX_DAY = 31;\nconst LEAP_REFERENCE_YEAR = 2000;\n\nfunction isEditableSegment(segment: SegmentState): segment is EditableSegmentState {\n    return segment.kind !== 'literal';\n}\n\n/** Tokeniza um `dateFormat` (ex.: `dd/MM/yyyy`, `MM/dd/yy`) em tokens de dia/mês/ano + literais. */\nexport function tokenizeDateFormat(format: string): FormatToken[] {\n    const tokens: FormatToken[] = [];\n    let lastIndex = 0;\n    DATE_FORMAT_TOKEN_RE.lastIndex = 0;\n    let match: RegExpExecArray | null;\n    while ((match = DATE_FORMAT_TOKEN_RE.exec(format))) {\n        if (match.index > lastIndex) {\n            tokens.push({ kind: 'literal', raw: format.slice(lastIndex, match.index) });\n        }\n        const raw = match[0];\n        const kind = raw[0] === 'y' ? 'year' : raw[0] === 'd' ? 'day' : 'month';\n        tokens.push({ kind, raw });\n        lastIndex = DATE_FORMAT_TOKEN_RE.lastIndex;\n    }\n    if (lastIndex < format.length) {\n        tokens.push({ kind: 'literal', raw: format.slice(lastIndex) });\n    }\n    return tokens;\n}\n\n/** Dias no mês (1-12), já resolvendo fevereiro/ano bissexto via rollover nativo do `Date`. */\nexport function daysInMonth(month: number, year: number): number {\n    return new Date(year, month, 0).getDate();\n}\n\nfunction buildDateSegments(dateFormat: string): SegmentState[] {\n    return tokenizeDateFormat(dateFormat).map((token): SegmentState => {\n        if (token.kind === 'literal') return { kind: 'literal', text: token.raw };\n        if (token.kind === 'year') return { kind: 'year', length: YEAR_SEGMENT_LENGTH, text: '' };\n        if (token.kind === 'month') return { kind: 'month', length: SHORT_SEGMENT_LENGTH, text: '' };\n        return { kind: 'day', length: SHORT_SEGMENT_LENGTH, text: '' };\n    });\n}\n\nfunction buildMonthSegments(dateFormat: string): SegmentState[] {\n    const all = buildDateSegments(dateFormat);\n    const dayIdx = all.findIndex((s) => s.kind === 'day');\n    if (dayIdx === -1) return all;\n    const dropIndexes = new Set<number>([dayIdx]);\n    if (all[dayIdx + 1]?.kind === 'literal') {\n        dropIndexes.add(dayIdx + 1);\n    } else if (all[dayIdx - 1]?.kind === 'literal') {\n        dropIndexes.add(dayIdx - 1);\n    }\n    return all.filter((_, i) => !dropIndexes.has(i));\n}\n\nfunction buildTimeSegments(hourFormat: '12' | '24', showSeconds: boolean): SegmentState[] {\n    const segments: SegmentState[] = [\n        { kind: 'hour', length: SHORT_SEGMENT_LENGTH, text: '' },\n        { kind: 'literal', text: ':' },\n        { kind: 'minute', length: SHORT_SEGMENT_LENGTH, text: '' },\n    ];\n    if (showSeconds) {\n        segments.push({ kind: 'literal', text: ':' }, { kind: 'second', length: SHORT_SEGMENT_LENGTH, text: '' });\n    }\n    if (hourFormat === '12') {\n        segments.push({ kind: 'literal', text: ' ' }, { kind: 'ampm', length: SHORT_SEGMENT_LENGTH, text: '' });\n    }\n    return segments;\n}\n\nfunction buildSegmentsFor(config: SegmentEngineConfig): SegmentState[] {\n    switch (config.mode) {\n        case 'date':\n            return buildDateSegments(config.dateFormat);\n        case 'month':\n            return buildMonthSegments(config.dateFormat);\n        case 'time':\n            return buildTimeSegments(config.hourFormat, config.showSeconds);\n        case 'datetime':\n            return [\n                ...buildDateSegments(config.dateFormat),\n                { kind: 'literal', text: ' ' },\n                ...buildTimeSegments(config.hourFormat, config.showSeconds),\n            ];\n    }\n}\n\n/**\n * Engine de segmentos (dia/mês/ano/hora/minuto/segundo/ampm) para o trigger do datepicker.\n * Sem dependências de Angular — DOM/CVA ficam por conta do componente que a consome.\n */\nexport class DateSegmentEngine {\n    private segments: SegmentState[] = [];\n    private config: SegmentEngineConfig | null = null;\n    private activeIndex: number | null = null;\n    private freshEntry = true;\n\n    configure(config: SegmentEngineConfig): void {\n        this.config = config;\n        this.segments = buildSegmentsFor(config);\n        this.activeIndex = null;\n        this.freshEntry = true;\n    }\n\n    getDisplayString(): string {\n        return this.segments.map((s) => (isEditableSegment(s) ? this.renderSegment(s) : s.text)).join('');\n    }\n\n    private renderSegment(segment: EditableSegmentState): string {\n        return segment.text + '_'.repeat(Math.max(0, segment.length - segment.text.length));\n    }\n\n    private segmentRenderLength(segment: SegmentState): number {\n        return isEditableSegment(segment) ? segment.length : segment.text.length;\n    }\n\n    getSegmentRange(index: number): [number, number] {\n        let start = 0;\n        for (let i = 0; i < index; i++) {\n            start += this.segmentRenderLength(this.segments[i]);\n        }\n        return [start, start + this.segmentRenderLength(this.segments[index])];\n    }\n\n    getFirstEditableIndex(): number {\n        return this.segments.findIndex((s) => isEditableSegment(s));\n    }\n\n    getLastEditableIndex(): number {\n        for (let i = this.segments.length - 1; i >= 0; i--) {\n            if (isEditableSegment(this.segments[i])) return i;\n        }\n        return -1;\n    }\n\n    getActiveIndex(): number | null {\n        return this.activeIndex;\n    }\n\n    activeKind(): SegmentKind | null {\n        if (this.activeIndex === null) return null;\n        const segment = this.segments[this.activeIndex];\n        return isEditableSegment(segment) ? segment.kind : null;\n    }\n\n    selectSegmentAt(charIndex: number): number {\n        let acc = 0;\n        for (let i = 0; i < this.segments.length; i++) {\n            const len = this.segmentRenderLength(this.segments[i]);\n            if (charIndex < acc + len) {\n                return this.nearestEditableFrom(i);\n            }\n            acc += len;\n        }\n        return this.getLastEditableIndex();\n    }\n\n    private nearestEditableFrom(index: number): number {\n        for (let i = index; i < this.segments.length; i++) {\n            if (isEditableSegment(this.segments[i])) return i;\n        }\n        return this.getLastEditableIndex();\n    }\n\n    selectSegment(index: number): void {\n        if (index < 0 || index >= this.segments.length || !isEditableSegment(this.segments[index])) return;\n        this.activeIndex = index;\n        this.freshEntry = true;\n    }\n\n    selectFirstSegment(): void {\n        this.selectSegment(this.getFirstEditableIndex());\n    }\n\n    /** Commita (pad/clamp) o segmento ativo e move para o próximo/anterior editável. */\n    moveToAdjacentSegment(direction: 1 | -1): 'moved' | 'boundary' {\n        this.commitActiveSegment();\n        if (this.activeIndex === null) return 'boundary';\n        let next = this.activeIndex;\n        do {\n            next += direction;\n        } while (next >= 0 && next < this.segments.length && !isEditableSegment(this.segments[next]));\n        if (next < 0 || next >= this.segments.length) {\n            this.activeIndex = null;\n            return 'boundary';\n        }\n        this.selectSegment(next);\n        return 'moved';\n    }\n\n    typeDigit(digit: string): void {\n        if (this.activeIndex === null) return;\n        const segment = this.segments[this.activeIndex];\n        if (!isEditableSegment(segment) || segment.kind === 'ampm') return;\n        if (this.freshEntry) {\n            segment.text = '';\n            this.freshEntry = false;\n        }\n        if (segment.text.length >= segment.length) return;\n        segment.text += digit;\n        if (segment.text.length >= segment.length) {\n            this.commitActiveSegment();\n            this.autoAdvance();\n        }\n    }\n\n    private autoAdvance(): void {\n        if (this.activeIndex === null) return;\n        let next = this.activeIndex;\n        do {\n            next += 1;\n        } while (next < this.segments.length && !isEditableSegment(this.segments[next]));\n        if (next < this.segments.length) {\n            this.selectSegment(next);\n        }\n    }\n\n    setAmPm(value: 0 | 1): void {\n        if (this.activeIndex === null) return;\n        const segment = this.segments[this.activeIndex];\n        if (!isEditableSegment(segment) || segment.kind !== 'ampm') return;\n        segment.text = value === 1 ? 'PM' : 'AM';\n        this.freshEntry = true;\n    }\n\n    clearActiveSegment(kind: 'backspace' | 'delete'): void {\n        if (this.activeIndex === null) return;\n        const segment = this.segments[this.activeIndex];\n        if (!isEditableSegment(segment)) return;\n        if (segment.text === '') {\n            if (kind === 'backspace') {\n                let prev = this.activeIndex;\n                do {\n                    prev -= 1;\n                } while (prev >= 0 && !isEditableSegment(this.segments[prev]));\n                if (prev >= 0) {\n                    this.activeIndex = prev;\n                    this.freshEntry = false;\n                }\n            }\n            return;\n        }\n        segment.text = '';\n        this.freshEntry = true;\n    }\n\n    /** Limpa todos os segmentos editáveis (usado quando o campo inteiro está selecionado, ex.: Ctrl+A). */\n    clearAll(): void {\n        for (const segment of this.segments) {\n            if (isEditableSegment(segment)) segment.text = '';\n        }\n        this.activeIndex = this.getFirstEditableIndex();\n        this.freshEntry = true;\n    }\n\n    /** Incrementa/decrementa o segmento ativo, dando a volta (wrap) dentro do range válido. */\n    incrementActiveSegment(delta: 1 | -1): void {\n        if (this.activeIndex === null) return;\n        const segment = this.segments[this.activeIndex];\n        if (!isEditableSegment(segment)) return;\n        if (segment.kind === 'ampm') {\n            this.setAmPm(segment.text === 'PM' ? 0 : 1);\n            return;\n        }\n        const { min, max } = this.boundsFor(segment.kind);\n        const range = max - min + 1;\n        const current = segment.text ? parseInt(segment.text, 10) : delta > 0 ? min - 1 : min;\n        const next = (((current + delta - min) % range) + range) % range + min;\n        segment.text = String(next).padStart(segment.length, '0');\n        this.freshEntry = true;\n        this.reconcileDayIfNeeded(segment.kind);\n    }\n\n    /** Pad/clamp do segmento ativo (ex.: \"2\" -> \"02\", \"45\" no dia -> clamp para daysInMonth). */\n    commitActiveSegment(): void {\n        if (this.activeIndex === null) return;\n        const segment = this.segments[this.activeIndex];\n        if (!isEditableSegment(segment)) return;\n        const kind = segment.kind;\n        segment.text = this.clampAndPad(segment);\n        this.freshEntry = true;\n        this.reconcileDayIfNeeded(kind);\n    }\n\n    /** Commita o segmento ativo e sai do modo de edição (usado no blur do campo). */\n    deactivate(): void {\n        this.commitActiveSegment();\n        this.activeIndex = null;\n    }\n\n    private clampAndPad(segment: EditableSegmentState): string {\n        if (segment.kind === 'ampm' || segment.kind === 'year' || !segment.text) {\n            return segment.text;\n        }\n        const num = parseInt(segment.text, 10);\n        const { min, max } = this.boundsFor(segment.kind);\n        const clamped = Math.min(max, Math.max(min, num));\n        return String(clamped).padStart(segment.length, '0');\n    }\n\n    private boundsFor(kind: SegmentKind): { min: number; max: number } {\n        switch (kind) {\n            case 'day':\n                return { min: 1, max: this.daysInMonthNow() };\n            case 'month':\n                return { min: 1, max: HOURS_PER_MERIDIEM };\n            case 'hour':\n                return this.config?.hourFormat === '12'\n                    ? { min: 1, max: HOURS_PER_MERIDIEM }\n                    : { min: 0, max: MAX_HOUR_24 };\n            case 'minute':\n            case 'second':\n                return { min: 0, max: MAX_MINUTE_SECOND };\n            default:\n                return { min: 0, max: 9999 };\n        }\n    }\n\n    /**\n     * Bound do dia dependendo do que já é conhecido de mês/ano. Nunca \"adivinha\" com o mês/ano\n     * atuais do sistema — isso estreitaria o range antes da hora (ex.: dia=29 digitado antes do\n     * ano, mês=fevereiro conhecido mas ano ainda não -> se assumisse o ano atual do sistema e ele\n     * não fosse bissexto, o dia seria clampado para 28 e nunca mais reexpandido para 29 mesmo que\n     * o ano realmente digitado depois seja bissexto). Em vez disso, fica sempre no lado permissivo\n     * até que a informação realmente exista.\n     */\n    private daysInMonthNow(): number {\n        const monthSegment = this.findEditable('month');\n        const monthKnown = !!monthSegment?.text && monthSegment.text.length === monthSegment.length;\n        if (!monthSegment || !monthKnown) return GENERIC_MAX_DAY;\n        const month = parseInt(monthSegment.text, 10);\n        const yearSegment = this.findEditable('year');\n        const yearKnown = !!yearSegment?.text && yearSegment.text.length === YEAR_SEGMENT_LENGTH;\n        if (!yearSegment || !yearKnown) return daysInMonth(month, LEAP_REFERENCE_YEAR);\n        return daysInMonth(month, parseInt(yearSegment.text, 10));\n    }\n\n    private reconcileDayIfNeeded(committedKind: SegmentKind): void {\n        if (committedKind !== 'month' && committedKind !== 'year') return;\n        const daySegment = this.findEditable('day');\n        if (!daySegment || daySegment.text.length !== daySegment.length) return;\n        const max = this.daysInMonthNow();\n        const dayNum = parseInt(daySegment.text, 10);\n        if (dayNum > max) {\n            daySegment.text = String(max).padStart(daySegment.length, '0');\n        }\n    }\n\n    private findEditable(kind: SegmentKind): EditableSegmentState | undefined {\n        return this.segments.find((s): s is EditableSegmentState => isEditableSegment(s) && s.kind === kind);\n    }\n\n    isEmpty(): boolean {\n        return this.segments.every((s) => !isEditableSegment(s) || s.text === '');\n    }\n\n    isComplete(): boolean {\n        return this.segments.every((s) => !isEditableSegment(s) || s.text.length === s.length);\n    }\n\n    loadFromDate(date: Date | null): void {\n        for (const segment of this.segments) {\n            if (isEditableSegment(segment)) segment.text = '';\n        }\n        this.activeIndex = null;\n        this.freshEntry = true;\n        if (!date) return;\n        for (const segment of this.segments) {\n            if (!isEditableSegment(segment)) continue;\n            segment.text = this.renderValueFor(segment.kind, date);\n        }\n    }\n\n    private renderValueFor(kind: SegmentKind, date: Date): string {\n        switch (kind) {\n            case 'day':\n                return String(date.getDate()).padStart(SHORT_SEGMENT_LENGTH, '0');\n            case 'month':\n                return String(date.getMonth() + 1).padStart(SHORT_SEGMENT_LENGTH, '0');\n            case 'year':\n                return String(date.getFullYear()).padStart(YEAR_SEGMENT_LENGTH, '0');\n            case 'hour': {\n                const h = date.getHours();\n                const display =\n                    this.config?.hourFormat === '12' ? (h % HOURS_PER_MERIDIEM === 0 ? HOURS_PER_MERIDIEM : h % HOURS_PER_MERIDIEM) : h;\n                return String(display).padStart(SHORT_SEGMENT_LENGTH, '0');\n            }\n            case 'minute':\n                return String(date.getMinutes()).padStart(SHORT_SEGMENT_LENGTH, '0');\n            case 'second':\n                return String(date.getSeconds()).padStart(SHORT_SEGMENT_LENGTH, '0');\n            case 'ampm':\n                return date.getHours() < HOURS_PER_MERIDIEM ? 'AM' : 'PM';\n        }\n    }\n\n    /** Constrói o `Date` a partir dos segmentos; `null` enquanto incompleto. Usa `referenceDate` para preencher partes ausentes (ex.: hora ao editar só a data). */\n    toDate(referenceDate?: Date | null): Date | null {\n        if (!this.isComplete()) return null;\n        const ref = referenceDate ?? new Date();\n        const getNum = (kind: SegmentKind): number | null => {\n            const segment = this.findEditable(kind);\n            return segment ? parseInt(segment.text, 10) : null;\n        };\n\n        const year = getNum('year') ?? ref.getFullYear();\n        const monthNum = getNum('month');\n        const month = monthNum !== null ? monthNum - 1 : ref.getMonth();\n        const day = this.config?.mode === 'month' ? 1 : (getNum('day') ?? ref.getDate());\n\n        let hour = getNum('hour');\n        const minute = getNum('minute') ?? ref.getMinutes();\n        const second = getNum('second') ?? ref.getSeconds();\n\n        if (hour !== null && this.config?.hourFormat === '12') {\n            const ampmSegment = this.findEditable('ampm');\n            const isPm = ampmSegment?.text === 'PM';\n            hour = hour % HOURS_PER_MERIDIEM;\n            if (isPm) hour += HOURS_PER_MERIDIEM;\n        }\n\n        return new Date(year, month, day, hour ?? ref.getHours(), minute, second);\n    }\n}\n"]}