Enum Order 

pub enum Order {
    Smart,
    Year,
    Day,
    Month,
}

Used by ParseCfg in Dt::from_str_parse. Controls how ambiguous dates (e.g. 01/02/03) are parsed.

The default Smart variant applies a practical heuristic that prefers year-first for compact formats and uses numeric plausibility checks for other cases. The other variants force a specific ordering.

Variants

Smart

Heuristic for mixed data. Uses the following rules, in this order:

1. Pure-numeric compact formats (≥ 6 digits with no separators, e.g. 240314153045, 20240315, YYMMDDHHMMSS): treated as Year-first (%Y%m%d / %y%m%d). These are overwhelmingly used in logs, filenames, databases, APIs, configs, and JSON for sortability.

2. Delimited formats that start with a plausible 4-digit year (1900–2100): treated as Year-first.

3. Numeric plausibility check (strongest universal signal):

   • First number is 13–31 → Day-first (international/European style).
   • First number is 1–12 and second number is 13–31 → Month-first (US style).

4. Strong ISO 8601 / timestamp markers (T connector, Z, numeric offsets, or IANA timezone names) → Year-first.

5. Fallback:

   • With the locale feature enabled: respects the system locale preference (Day-first in most of the world).
   • Without the locale feature: Day-first (global majority).

The / separator is deliberately ignored in the plausibility step because it is culturally ambiguous.

Once the preferred ordering is determined, the parser tries that order first, then the other two (e.g. Day → Month → Year), before any year-first unambiguous fallback.

Year

Prefer Year-first (YYYY/MM/DD or YY/MM/DD), then Day, then Month.

Day

Prefer Day-first (DD/MM/YYYY), then Month, then Year.

Month

Prefer Month-first (MM/DD/YYYY), then Day, then Year.

Trait Implementations

impl Clone for Order

fn clone(&self) -> Order

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Order

impl Debug for Order

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Order

fn default() -> Order

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Order

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Order

fn eq(&self, other: &Order) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Order

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Order

impl Tsify for Order

const DECL: &'static str = "/**\n * Used by [`ParseCfg`] in\n * [`Dt::from_str_parse`](../struct.Dt.html#method.from_str_parse). Controls\n * how ambiguous dates (e.g. `01/02/03`) are parsed.\n *\n * The default `Smart` variant applies a practical heuristic that prefers\n * year-first for compact formats and uses numeric plausibility checks\n * for other cases. The other variants force a specific ordering.\n */\nexport type Order = \"Smart\" | \"Year\" | \"Day\" | \"Month\";"

const SERIALIZATION_CONFIG: SerializationConfig

type JsType = JsType

Must be a type imported through #[wasm_bindgen] extern "C" { .. }. Ts<T> is #[repr(transparent)] over this and passes it across the ABI as a plain JS handle, which any other representation would break.

fn into_js(&self) -> Result<Self::JsType, Error>

where Self: Serialize,

fn from_js<T>(js: T) -> Result<Self, Error>

where T: Into<JsValue>, Self: DeserializeOwned,

fn into_ts(&self) -> Result<Ts<Self>, Error>

where Self: Sized + Serialize,

Calls Ts::from_rust on self, returning a Result<Ts<Self>, crate::Error>.