@everwhen/temporal/dist/is.js

import invariant from 'tiny-invariant';
import { Instant } from './instant.js';
import { Interval } from './interval.js';
import { PlainDateTime } from './plain-date-time.js';
import { PlainDate } from './plain-date.js';
import { PlainTime } from './plain-time.js';
import { PlainYearMonth } from './plain-year-month.js';
import { ZonedDateTime } from './zoned-date-time.js';
function tryIt(fn) {
    try {
        fn();
        return true;
    }
    catch (error) {
        return false;
    }
}
export const isString = (value) => typeof value === 'string';
export const isObject = (value) => typeof value === 'object';
export function isInstanceOf(instance, class_) {
    if (instance === undefined || instance === null) {
        return false;
    }
    return Object.getPrototypeOf(instance) === class_.prototype;
}
export function isTemporalKind(value, class_) {
    return isString(value)
        ? tryIt(() => 'from' in class_ &&
            typeof class_.from === 'function' &&
            class_.from(value))
        : isInstanceOf(value, class_);
}
export function isInstant(value) {
    return isTemporalKind(value, Instant);
}
export function isPlainDate(value) {
    return isTemporalKind(value, PlainDate);
}
export function isPlainDateTime(value) {
    return isTemporalKind(value, PlainDateTime);
}
export function isPlainTime(value) {
    return isTemporalKind(value, PlainTime);
}
export function isPlainYearMonth(value) {
    return isTemporalKind(value, PlainYearMonth);
}
export function isZonedDateTime(value) {
    return isTemporalKind(value, ZonedDateTime);
}
export function isPoint(value, typeGuard) {
    return typeGuard
        ? typeGuard(value)
        : isPlainTime(value) ||
            isPlainDateTime(value) ||
            isPlainDate(value) ||
            isPlainYearMonth(value) ||
            isZonedDateTime(value);
}
export function isPointAny(value, typeGuards) {
    return typeGuards.some((guard) => guard(value));
}
export function isInterval(value, typeGuard) {
    if (typeGuard) {
        return (isInstanceOf(value, Interval) &&
            typeGuard(value.start) &&
            typeGuard(value.end));
    }
    return isInstanceOf(value, Interval);
}
export function isIntervalLike(value, typeGuard) {
    return (isInterval(value, typeGuard) ||
        (!!value &&
            isObject(value) &&
            'start' in value &&
            'end' in value &&
            (typeGuard ? typeGuard(value.start) : isPoint(value.start)) &&
            (typeGuard ? typeGuard(value.end) : isPoint(value.end))));
}
export function isIntervalLikeOneOf(value, typeGuards) {
    return (isIntervalLike(value) &&
        typeGuards.some((guard) => guard(value.start) && guard(value.end)));
}
export function assertPoint(value, typeGuard, message) {
    invariant(isPoint(value, typeGuard), message);
}
export function assertPlainDateTime(value, message) {
    invariant(isPlainDateTime(value), message);
}
export function assertPlainTime(value, message) {
    invariant(isPlainTime(value), message);
}
export function assertPlainYearMonth(value, message) {
    invariant(isPlainYearMonth(value), message);
}
export function assertPlainDate(value, message) {
    invariant(isPlainDate(value), message);
}
export function assertInstant(value, message) {
    invariant(isInstant(value), message);
}
export function assertZonedDateTime(value, message) {
    invariant(isZonedDateTime(value), message);
}
export function assertInterval(value, typeGuard, message) {
    invariant(isInterval(value, typeGuard), message);
}
export function assertIntervalLike(value, typeGuard, message) {
    invariant(isIntervalLike(value, typeGuard), message);
}
//# sourceMappingURL=is.js.map