@globalbrain/sefirot 4.31.0 → 4.32.0

package/lib/composables/Utils.ts

@@ -1,5 +1,12 @@
-import { type ComputedRef, type MaybeRefOrGetter, computed, getCurrentInstance, onMounted, toValue, useSlots } from 'vue'
-import { isString } from '../support/Utils'
+import {
+  type ComputedRef,
+  type MaybeRefOrGetter,
+  computed,
+  getCurrentInstance,
+  onMounted,
+  toValue,
+  useSlots
+} from 'vue'
 
 export type WhenCondition<T> = MaybeRefOrGetter<T>
 
@@ -22,7 +29,7 @@ export function computedWhen<T, C, D>(
   return computed(() => {
     const c = toValue(condition)
 
-    return c ? fn(c) : whenFalse as D
+    return c ? fn(c) : (whenFalse as D)
   })
 }
 
@@ -68,7 +75,7 @@ export function useSlotValue(name = 'default'): ComputedRef<string | null> {
 
   return computed(() => {
     const c = slots[name]?.()[0]?.children
-    const v = isString(c) ? c.trim() : null
+    const v = typeof c === 'string' ? c.trim() : null
     return v !== '' ? v : null
   })
 }

package/lib/composables/Validation.ts

@@ -85,10 +85,7 @@ export function useVNotification(): VNotification {
   const snackbars = useSnackbars()
 
   function notify(message?: Snackbar): void {
-    snackbars.push(message ?? {
-      mode: 'danger',
-      text: t.notify
-    })
+    snackbars.push(message ?? { mode: 'danger', text: t.notify })
   }
 
   return {

package/lib/http/Http.ts

@@ -3,7 +3,6 @@ import { parse as parseCookie } from '@tinyhttp/cookie'
 import FileSaver from 'file-saver'
 import { FetchError, type FetchOptions, type FetchResponse } from 'ofetch'
 import { stringify } from 'qs'
-import { isBlob, isError, isFormData, isRequest, isResponse, isString } from '../support/Utils'
 
 type Config = ReturnType<typeof import('../stores/HttpConfig').useHttpConfig>
 
@@ -31,9 +30,13 @@ export class Http {
 
   private async buildRequest(url: string, _options: FetchOptions = {}): Promise<[string, FetchOptions]> {
     const { method, params, query, ...options } = _options
-    const xsrfToken = ['POST', 'PUT', 'PATCH', 'DELETE'].includes(method || '') && (await this.ensureXsrfToken())
+    const xsrfToken = ['POST', 'PUT', 'PATCH', 'DELETE'].includes(method || '')
+      && (await this.ensureXsrfToken())
 
-    const queryString = stringify({ ...params, ...query }, { encodeValuesOnly: true, ...this.config.stringifyOptions })
+    const queryString = stringify(
+      { ...params, ...query },
+      { encodeValuesOnly: true, ...this.config.stringifyOptions }
+    )
 
     return [
       `${url}${queryString ? `?${queryString}` : ''}`,
@@ -70,11 +73,11 @@ export class Http {
   }
 
   async post<T = any>(url: string, body?: any, options?: FetchOptions): Promise<T> {
-    if (body && !isFormData(body)) {
+    if (body && !(body instanceof FormData)) {
       let hasFile = false
 
       const payload = JSON.stringify(body, (_, value) => {
-        if (isBlob(value)) {
+        if (value instanceof Blob) {
           hasFile = true
           return undefined
         }
@@ -120,13 +123,18 @@ export class Http {
       throw new Error('No blob')
     }
 
-    const { filename = 'download' }
-      = parseContentDisposition(headers.get('Content-Disposition') || '')?.parameters || {}
+    const { filename = 'download' } =
+      parseContentDisposition(headers.get('Content-Disposition') || '')?.parameters || {}
 
     FileSaver.saveAs(blob, filename as string)
   }
 
-  private objectToFormData(obj: any, form?: FormData, namespace?: string, onlyFiles = false): FormData {
+  private objectToFormData(
+    obj: any,
+    form?: FormData,
+    namespace?: string,
+    onlyFiles = false
+  ): FormData {
     const fd = form || new FormData()
     let formKey: string
 
@@ -141,11 +149,15 @@ export class Http {
         return
       }
 
-      if (typeof obj[property] === 'object' && !isBlob(obj[property]) && obj[property] !== null) {
+      if (
+        typeof obj[property] === 'object'
+        && !(obj[property] instanceof Blob)
+        && obj[property] !== null
+      ) {
         this.objectToFormData(obj[property], fd, property, onlyFiles)
       } else {
         const value = obj[property] === null ? '' : obj[property]
-        if (onlyFiles && !isBlob(value)) {
+        if (onlyFiles && !(value instanceof Blob)) {
           return
         }
         fd.append(formKey, value)
@@ -157,13 +169,7 @@ export class Http {
 }
 
 export function isFetchError(e: unknown): e is FetchError {
-  return (
-    e instanceof FetchError
-    || (isError<FetchError>(e)
-      && (e.response === undefined || isResponse(e.response))
-      && ((isString(e.request) && e.message.startsWith(`[${e.options?.method || 'GET'}] ${JSON.stringify(e.request || '/')}: `))
-        || (isRequest(e.request) && e.message.startsWith(`[${e.request.method}] ${JSON.stringify(e.request.url)}: `))))
-  )
+  return e instanceof FetchError || (e instanceof Error && e.name === 'FetchError')
 }
 
 export { FetchError, type FetchOptions, type FetchRequest, type FetchResponse } from 'ofetch'

package/lib/styles/variables-deprecated.css

@@ -110,7 +110,6 @@
  */
 :root {
   --c-soft: var(--c-white-soft);
-
 }
 
 .dark {

package/lib/styles/variables.css

@@ -154,7 +154,7 @@
  * Color: Divider and Gutter
  * -------------------------------------------------------------------------- */
 
- :root {
+:root {
   --c-divider: #e0e0e1;
   --c-gutter: #e2e2e3;
 }
@@ -290,7 +290,7 @@
  * Color: Border
  * -------------------------------------------------------------------------- */
 
- :root {
+:root {
   --c-border-mute-1: var(--c-gray-6);
   --c-border-mute-2: var(--c-gray-7);
   --c-border-mute-3: var(--c-gray-8);
@@ -316,7 +316,7 @@
  * Color: Text
  * -------------------------------------------------------------------------- */
 
- :root {
+:root {
   --c-text-1: var(--c-text-light-1);
   --c-text-2: var(--c-text-light-2);
   --c-text-3: var(--c-text-light-3);
@@ -367,11 +367,11 @@
  * -------------------------------------------------------------------------- */
 
 :root {
-  --shadow-depth-1: 0 1px 2px rgba(0, 0, 0, .04), 0 1px 2px rgba(0, 0, 0, .06);
-  --shadow-depth-2: 0 3px 12px rgba(0, 0, 0, .07), 0 1px 4px rgba(0, 0, 0, .07);
-  --shadow-depth-3: 0 12px 32px rgba(0, 0, 0, .1), 0 2px 6px rgba(0, 0, 0, .08);
-  --shadow-depth-4: 0 14px 44px rgba(0, 0, 0, .12), 0 3px 9px rgba(0, 0, 0, .12);
-  --shadow-depth-5: 0 18px 56px rgba(0, 0, 0, .16), 0 4px 12px rgba(0, 0, 0, .16);
+  --shadow-depth-1: 0 1px 2px rgba(0, 0, 0, 0.04), 0 1px 2px rgba(0, 0, 0, 0.06);
+  --shadow-depth-2: 0 3px 12px rgba(0, 0, 0, 0.07), 0 1px 4px rgba(0, 0, 0, 0.07);
+  --shadow-depth-3: 0 12px 32px rgba(0, 0, 0, 0.1), 0 2px 6px rgba(0, 0, 0, 0.08);
+  --shadow-depth-4: 0 14px 44px rgba(0, 0, 0, 0.12), 0 3px 9px rgba(0, 0, 0, 0.12);
+  --shadow-depth-5: 0 18px 56px rgba(0, 0, 0, 0.16), 0 4px 12px rgba(0, 0, 0, 0.16);
 }
 
 /**
@@ -389,15 +389,15 @@
  * -------------------------------------------------------------------------- */
 
 :root {
-  --ease-in-quint: cubic-bezier(.755, .05, .855, .06);
-  --ease-in-back: cubic-bezier(1, -.75, 1, 1);
+  --ease-in-quint: cubic-bezier(0.755, 0.05, 0.855, 0.06);
+  --ease-in-back: cubic-bezier(1, -0.75, 1, 1);
 
-  --ease-out-quint: cubic-bezier(.23, 1, .32, 1);
-  --ease-out-expo: cubic-bezier(.19, 1, .22, 1);
-  --ease-out-back: cubic-bezier(.175, .885, .320, 1.275);
-  --ease-out-back-quint: cubic-bezier(.175, .885, .280, 1.5);
+  --ease-out-quint: cubic-bezier(0.23, 1, 0.32, 1);
+  --ease-out-expo: cubic-bezier(0.19, 1, 0.22, 1);
+  --ease-out-back: cubic-bezier(0.175, 0.885, 0.32, 1.275);
+  --ease-out-back-quint: cubic-bezier(0.175, 0.885, 0.28, 1.5);
 
-  --ease-in-out-quint: cubic-bezier(.86, 0, .07, 1);
+  --ease-in-out-quint: cubic-bezier(0.86, 0, 0.07, 1);
   --ease-in-out-expo: cubic-bezier(1, 0, 0, 1);
 }
 
@@ -503,7 +503,7 @@
   --button-fill-black-hover-text-color: var(--c-text-dark-1);
   --button-fill-black-hover-bg-color: var(--c-neutral-light-2);
   --button-fill-black-active-border-color: transparent;
-  --button-fill-black-active-text-color:var(--c-text-dark-1);
+  --button-fill-black-active-text-color: var(--c-text-dark-1);
   --button-fill-black-active-bg-color: var(--c-neutral-light-3);
   --button-fill-black-disabled-border-color: transparent;
   --button-fill-black-disabled-text-color: var(--c-text-dark-2);

package/lib/support/Chart.ts

@@ -37,7 +37,6 @@ export const chartColors = {
   gray: 'light-dark(#8d8d8d, #7b7b7b)'
 } as const
 
-// eslint-disable-next-line @typescript-eslint/ban-types
 export type ChartColor = keyof typeof chartColors | (string & {})
 export type KV = { key: string; value: number; color?: ChartColor }
 export type Margins = Partial<{ top: number; right: number; bottom: number; left: number }>

package/lib/support/DateRange.ts

@@ -93,7 +93,7 @@ export class DateFromTo extends DateRangePresetBase {
     const f = this.getFrom()?.format('YYYY-MM-DD')
     const t = this.getTo()?.format('YYYY-MM-DD')
 
-    return (f && t) ? `${f} – ${t}` : 'Error'
+    return f && t ? `${f} – ${t}` : 'Error'
   }
 
   setFrom(from: Day | null): this {

package/lib/support/Day.ts

@@ -2,7 +2,6 @@ import dayjs, { type ConfigType, type Dayjs } from 'dayjs'
 import PluginRelativeTime from 'dayjs/plugin/relativeTime'
 import PluginTimezone from 'dayjs/plugin/timezone'
 import PluginUtc from 'dayjs/plugin/utc'
-import { isNumber, isObject, isString } from './Utils'
 
 dayjs.extend(PluginUtc)
 dayjs.extend(PluginTimezone)
@@ -22,12 +21,6 @@ export interface Ymd {
 
 export type YmdType = 'y' | 'm' | 'd'
 
-export const YmdMap = {
-  y: 'year',
-  m: 'month',
-  d: 'date'
-} as const
-
 /**
  * The hour, minute, and second object interface.
  */
@@ -39,13 +32,13 @@ export interface Hms {
 
 export type HmsType = 'h' | 'm' | 's'
 
-export const HmsMap = {
-  h: 'hour',
-  m: 'minute',
-  s: 'second'
-} as const
-
 export function day(input?: Input): Day {
+  // hack for histoire
+  if (input && typeof input === 'object' && !(input instanceof Date)) {
+    const { $D, $H, $M, $m, $ms, $s, $y } = input as any
+    input = new Date($y, $M, $D, $H, $m, $s, $ms)
+  }
+
   return dayjs(input)
 }
 
@@ -67,19 +60,9 @@ export function createYmd(
   month: number | null = null,
   date: number | null = null
 ): Ymd {
-  if (isNumber(yearOrDay) || yearOrDay == null) {
-    return {
-      year: yearOrDay,
-      month,
-      date
-    }
-  }
-
-  return {
-    year: yearOrDay.year(),
-    month: yearOrDay.month() + 1,
-    date: yearOrDay.date()
-  }
+  return isDay(yearOrDay)
+    ? { year: yearOrDay.year(), month: yearOrDay.month() + 1, date: yearOrDay.date() }
+    : { year: yearOrDay, month, date }
 }
 
 /**
@@ -92,45 +75,9 @@ export function createHms(
   minute: string | null = null,
   second: string | null = null
 ): Hms {
-  if (isString(hourOrDay) || hourOrDay == null) {
-    return {
-      hour: hourOrDay,
-      minute,
-      second
-    }
-  }
-
-  return {
-    hour: hourOrDay.format('HH'),
-    minute: hourOrDay.format('mm'),
-    second: hourOrDay.format('ss')
-  }
-}
-
-export function isYmd(value: unknown, required: YmdType[] = ['y', 'm', 'd']): value is Ymd {
-  if (value == null || !isObject(value)) {
-    return false
-  }
-
-  return required
-    .reduce<string[]>((keys, type) => {
-      keys.push(YmdMap[type])
-      return keys
-    }, [])
-    .every((key) => value[key] === null || isNumber(value[key]))
-}
-
-export function isHms(value: unknown, required: HmsType[] = ['h', 'm', 's']): value is Hms {
-  if (value == null || !isObject(value)) {
-    return false
-  }
-
-  return required
-    .reduce<string[]>((keys, type) => {
-      keys.push(HmsMap[type])
-      return keys
-    }, [])
-    .every((key) => value[key] === null || isString(value[key]))
+  return isDay(hourOrDay)
+    ? { hour: hourOrDay.format('HH'), minute: hourOrDay.format('mm'), second: hourOrDay.format('ss') }
+    : { hour: hourOrDay, minute, second }
 }
 
 export function isDay(value: unknown): value is Day {

package/lib/support/File.ts

@@ -1,24 +1,15 @@
-/**
- * Get extension of the given file.
- */
-export function getExtension(file: File): string {
-  const name = file.name
-
-  return name.slice((name.lastIndexOf('.') - 1 >>> 0) + 2)
-}
+const units = ['B', 'kB', 'MB', 'GB'] as const
 
 /**
  * Formats the file size in bytes to a human-readable format. It also accepts
  * array of files and returns the total size.
  */
 export function formatSize(files: File | File[]): string {
-  const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB']
   files = Array.isArray(files) ? files : [files]
-  let size = files.reduce((previous, file) => previous + file.size, 0)
-  let index = 0
-  while (size >= 1024 && index < units.length) {
-    size /= 1024
-    index++
-  }
-  return `${size.toFixed(2)}${units[index]}`
+
+  const size = files.reduce((sum, file) => sum + file.size, 0)
+  if (size === 0) { return `0 ${units[0]}` }
+
+  const i = Math.min(Math.floor(Math.log(size) / Math.log(1000)), units.length - 1)
+  return `${(size / 1000 ** i).toFixed(2)} ${units[i]}`
 }

package/lib/support/Utils.ts

@@ -1,49 +1,16 @@
-// eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
-// @ts-ignore internal
-import baseGetTag from 'lodash-es/_baseGetTag'
-
-import _isDate from 'lodash-es/isDate'
-import _isError from 'lodash-es/isError'
-import _isNumber from 'lodash-es/isNumber'
-import _isPlainObject from 'lodash-es/isPlainObject'
-import _isString from 'lodash-es/isString'
-
-export function isBlob(value: unknown): value is Blob {
-  return value instanceof Blob || baseGetTag(value) === '[object Blob]'
-}
-
-export function isDate(value: unknown): value is Date {
-  return _isDate(value)
-}
-
-export function isError<T extends Error = Error>(value: unknown): value is T {
-  return _isError(value)
-}
-
-export function isFile(value: unknown): value is File {
-  return value instanceof File || baseGetTag(value) === '[object File]'
-}
-
-export function isFormData(value: unknown): value is FormData {
-  return value instanceof FormData || baseGetTag(value) === '[object FormData]'
-}
-
+/** @deprecated */
 export function isNumber(value: unknown): value is number {
-  return _isNumber(value)
+  return Number.isFinite(value)
 }
 
 export function isObject(value: unknown): value is Record<string, unknown> {
-  return _isPlainObject(value)
-}
-
-export function isRequest(value: unknown): value is Request {
-  return value instanceof Request || baseGetTag(value) === '[object Request]'
-}
+  if (value == null || typeof value !== 'object') { return false }
 
-export function isResponse(value: unknown): value is Response {
-  return value instanceof Response || baseGetTag(value) === '[object Response]'
+  const proto = Object.getPrototypeOf(value)
+  return proto === null || proto === Object.prototype
 }
 
+/** @deprecated */
 export function isString(value: unknown): value is string {
-  return _isString(value)
+  return typeof value === 'string'
 }

package/lib/validation/Rule.ts

@@ -1,7 +1,7 @@
 import { type ValidationRuleWithParams } from '@vuelidate/core'
 import { type MessageProps as VMessageProps, helpers } from '@vuelidate/validators'
 import { type Lang } from '../composables/Lang'
-import { _required } from './validators'
+import { required } from './validators'
 
 export interface RuleOptions {
   optional?: boolean
@@ -15,34 +15,19 @@ export interface MessageProps extends VMessageProps {
   lang: Lang
 }
 
-export function createRule(
-  options: RuleOptions
-): ValidationRuleWithParams {
+export function createRule(options: RuleOptions): ValidationRuleWithParams {
   const lang = typeof document !== 'undefined'
     ? (document.documentElement.lang === 'ja' ? 'ja' : 'en')
     : 'en'
 
   const params = options.params ?? {}
 
-  const validator = helpers.withParams(
-    params,
-    (value: unknown) => {
-      return options.optional && !_required(value)
-        ? true
-        : options.validation(value)
-    }
-  )
+  const validator = helpers.withParams(params, (value: unknown) => {
+    return options.optional && !required(value, false) ? true : options.validation(value)
+  })
 
   return helpers.withMessage(
     (params) => options.message({ ...params, lang }),
-    options.async
-      ? helpers.withAsync(validator, createParamsForAsyncValidator(params))
-      : validator
+    options.async ? helpers.withAsync(validator, Object.values(params)) : validator
   )
 }
-
-function createParamsForAsyncValidator(params: Record<string, any>) {
-  return Object.keys(params).map((key) => {
-    return params[key]
-  })
-}

package/lib/validation/rules/decimal.ts

@@ -1,8 +1,8 @@
 import { createRule } from '../Rule'
-import { decimal as baseDecimal, hyphen } from '../validators'
+import { decimal as baseDecimal } from '../validators'
 
 export const message = {
-  en: 'The value must be valid decimal numbers.',
+  en: 'The value must be a valid decimal number.',
   ja: 'この値は小数または10進数である必要があります。'
 }
 
@@ -10,6 +10,6 @@ export function decimal(msg?: string) {
   return createRule({
     message: ({ lang }) => msg ?? message[lang],
     optional: true,
-    validation: (value) => !hyphen(value) && baseDecimal(value)
+    validation: (value) => baseDecimal(value)
   })
 }

package/lib/validation/rules/email.ts

@@ -2,7 +2,7 @@ import { createRule } from '../Rule'
 import { email as baseEmail } from '../validators'
 
 export const message = {
-  en: 'The Email is invalid.',
+  en: 'The email is invalid.',
   ja: 'Emailの形式が正しくありません。'
 }
 

package/lib/validation/rules/index.ts

@@ -1,4 +1,3 @@
-export { and, not, or } from '@vuelidate/validators'
 export { after } from './after'
 export { afterOrEqual } from './afterOrEqual'
 export { before } from './before'
@@ -30,3 +29,4 @@ export { url } from './url'
 export { ymd } from './ymd'
 export { zeroOrNegativeInteger } from './zeroOrNegativeInteger'
 export { zeroOrPositiveInteger } from './zeroOrPositiveInteger'
+export { and, not, or } from '@vuelidate/validators'

package/lib/validation/rules/negativeInteger.ts

@@ -2,7 +2,7 @@ import { createRule } from '../Rule'
 import { negativeInteger as baseNegativeInteger } from '../validators'
 
 export const message = {
-  en: 'The value must be valid negative integer.',
+  en: 'The value must be a valid negative integer.',
   ja: 'この値は負の整数である必要があります。'
 }
 

package/lib/validation/rules/positiveInteger.ts

@@ -2,7 +2,7 @@ import { createRule } from '../Rule'
 import { positiveInteger as basePositiveInteger } from '../validators'
 
 export const message = {
-  en: 'The value must be valid positive integer.',
+  en: 'The value must be a valid positive integer.',
   ja: 'この値は正の整数である必要があります。'
 }
 

package/lib/validation/rules/requiredHms.ts

@@ -1,6 +1,6 @@
 import { type HmsType } from '../../support/Day'
 import { createRule } from '../Rule'
-import { requiredHms as baseRequiredHms } from '../validators/requiredHms'
+import { hms as baseHms } from '../validators/hms'
 
 export const message = {
   en: 'The field is required.',
@@ -10,6 +10,6 @@ export const message = {
 export function requiredHms(required?: HmsType[], msg?: string) {
   return createRule({
     message: ({ lang }) => msg ?? message[lang],
-    validation: (value) => baseRequiredHms(value, required)
+    validation: (value) => baseHms(value, required, true)
   })
 }

package/lib/validation/rules/requiredIf.ts

@@ -6,10 +6,7 @@ export const message = {
   ja: 'この項目は必須です。'
 }
 
-export function requiredIf(
-  condition: RequiredIfCondition,
-  msg?: string
-) {
+export function requiredIf(condition: RequiredIfCondition, msg?: string) {
   return createRule({
     async: true,
     params: { condition },

package/lib/validation/rules/requiredYmd.ts

@@ -1,6 +1,6 @@
 import { type YmdType } from '../../support/Day'
 import { createRule } from '../Rule'
-import { requiredYmd as baseRequiredYmd } from '../validators/requiredYmd'
+import { ymd as baseYmd } from '../validators/ymd'
 
 export const message = {
   en: 'The field is required.',
@@ -10,6 +10,6 @@ export const message = {
 export function requiredYmd(required?: YmdType[], msg?: string) {
   return createRule({
     message: ({ lang }) => msg ?? message[lang],
-    validation: (value) => baseRequiredYmd(value, required)
+    validation: (value) => baseYmd(value, required, true)
   })
 }

package/lib/validation/rules/slackChannelName.ts

@@ -1,5 +1,8 @@
 import { createRule } from '../Rule'
-import { type SlackChannelNameOptions, slackChannelName as baseSlackChannelName } from '../validators'
+import {
+  type SlackChannelNameOptions,
+  slackChannelName as baseSlackChannelName
+} from '../validators'
 
 export const message = {
   en: 'The slack channel name is invalid.',

package/lib/validation/rules/zeroOrNegativeInteger.ts

@@ -2,7 +2,7 @@ import { createRule } from '../Rule'
 import { negativeInteger as baseNegativeInteger, zero } from '../validators'
 
 export const message = {
-  en: 'The value must be zero or valid negative integer.',
+  en: 'The value must be zero or a valid negative integer.',
   ja: 'この値はゼロまたは負の整数である必要があります。'
 }
 

package/lib/validation/rules/zeroOrPositiveInteger.ts

@@ -2,7 +2,7 @@ import { createRule } from '../Rule'
 import { positiveInteger as basePositiveInteger, zero } from '../validators'
 
 export const message = {
-  en: 'The value must be zero or valid positive integer.',
+  en: 'The value must be zero or a valid positive integer.',
   ja: 'この値はゼロまたは正の整数である必要があります。'
 }
 

package/lib/validation/validators/after.ts

@@ -1,9 +1,5 @@
 import { type Day, isDay } from '../../support/Day'
 
 export function after(value: unknown, date: Day): boolean {
-  if (!isDay(value) || !isDay(date)) {
-    return false
-  }
-
-  return value.isAfter(date)
+  return isDay(value) && isDay(date) && value.isAfter(date, 'day')
 }

package/lib/validation/validators/afterOrEqual.ts

@@ -1,9 +1,5 @@
 import { type Day, isDay } from '../../support/Day'
 
 export function afterOrEqual(value: unknown, date: Day): boolean {
-  if (!isDay(value) || !isDay(date)) {
-    return false
-  }
-
-  return value.isAfter(date) || value.isSame(date)
+  return isDay(value) && isDay(date) && (value.isAfter(date, 'day') || value.isSame(date, 'day'))
 }

package/lib/validation/validators/before.ts

@@ -1,8 +1,5 @@
 import { type Day, isDay } from '../../support/Day'
 
 export function before(value: unknown, date: Day): boolean {
-  if (!isDay(value) || !isDay(date)) {
-    return false
-  }
-  return value.isBefore(date)
+  return isDay(value) && isDay(date) && value.isBefore(date, 'day')
 }