@planet-matrix/mobius-model 0.3.0 → 0.5.0

package/src/type/boolean.ts

@@ -0,0 +1,471 @@
+// ============================================================================
+// Helpers
+// ============================================================================
+
+type InternalBuildArray<N extends number, Acc extends readonly unknown[] = []> =
+  Acc['length'] extends N ? Acc : InternalBuildArray<N, [...Acc, unknown]>
+
+type InternalIsGreaterThan<A extends number, B extends number> =
+  A extends B ? false : (
+    InternalBuildArray<A> extends [...InternalBuildArray<B>, ...infer _Rest]
+    ? (_Rest extends [unknown, ...unknown[]] ? true : false)
+    : false
+  )
+
+// ============================================================================
+// Primitives
+// ============================================================================
+
+/**
+ * Conditional type selector based on a boolean value (ternary operator).
+ *
+ * @example
+ * ```
+ * // Expect: 'yes'
+ * type Example1 = BooleanIf<true, 'yes', 'no'>
+ * // Expect: 'no'
+ * type Example2 = BooleanIf<false, 'yes', 'no'>
+ * ```
+ */
+export type BooleanIf<Condition extends boolean, Then, Else> = Condition extends true ? Then : Else
+
+// ============================================================================
+// Comparison
+// ============================================================================
+
+/**
+ * Check if two boolean values are equal.
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * type Example1 = BooleanIsEqual<true, true>
+ * // Expect: true
+ * type Example2 = BooleanIsEqual<false, false>
+ * // Expect: false
+ * type Example3 = BooleanIsEqual<true, false>
+ * ```
+ */
+export type BooleanIsEqual<T extends boolean, U extends boolean> =
+  T extends U ? (U extends T ? true : false) : false
+
+/**
+ * Logical implication (A → B), equivalent to ¬A ∨ B.
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * type Example1 = BooleanImplies<true, true>
+ * // Expect: false
+ * type Example2 = BooleanImplies<true, false>
+ * // Expect: true
+ * type Example3 = BooleanImplies<false, true>
+ * // Expect: true
+ * type Example4 = BooleanImplies<false, false>
+ * ```
+ */
+export type BooleanImplies<T extends boolean, U extends boolean> =
+  T extends true ? (U extends true ? true : false) : true
+
+// ============================================================================
+// Query
+// ============================================================================
+
+type InternalBooleanCountTrue<T extends readonly boolean[], Acc extends readonly unknown[] = []> =
+  T extends [infer First extends boolean, ...infer Rest extends boolean[]]
+  ? (First extends true ? InternalBooleanCountTrue<Rest, [...Acc, unknown]> : InternalBooleanCountTrue<Rest, Acc>)
+  : Acc['length']
+/**
+ * Count the number of true values in a boolean tuple.
+ *
+ * @example
+ * ```
+ * // Expect: 2
+ * type Example1 = BooleanCountTrue<[true, false, true]>
+ * // Expect: 0
+ * type Example2 = BooleanCountTrue<[false, false]>
+ * ```
+ */
+export type BooleanCountTrue<T extends readonly boolean[]> = InternalBooleanCountTrue<T>
+
+type InternalBooleanCountFalse<T extends readonly boolean[], Acc extends readonly unknown[] = []> =
+  T extends [infer First extends boolean, ...infer Rest extends boolean[]]
+  ? (First extends false ? InternalBooleanCountFalse<Rest, [...Acc, unknown]> : InternalBooleanCountFalse<Rest, Acc>)
+  : Acc['length']
+/**
+ * Count the number of false values in a boolean tuple.
+ *
+ * @example
+ * ```
+ * // Expect: 2
+ * type Example1 = BooleanCountFalse<[true, false, false]>
+ * // Expect: 0
+ * type Example2 = BooleanCountFalse<[true, true]>
+ * ```
+ */
+export type BooleanCountFalse<T extends readonly boolean[]> = InternalBooleanCountFalse<T>
+
+/**
+ * Count the number of true or false values in a boolean tuple.
+ *
+ * @example
+ * ```
+ * // Expect: 2
+ * type Example1 = BooleanCount<[true, false, true], true>
+ * // Expect: 1
+ * type Example2 = BooleanCount<[true, false, true], false>
+ * ```
+ */
+export type BooleanCount<T extends readonly boolean[], Value extends boolean> =
+  Value extends true ? BooleanCountTrue<T> : BooleanCountFalse<T>
+
+type InternalBooleanFindIndex<T extends readonly boolean[], Value extends boolean, Index extends readonly unknown[] = []> =
+  T extends [infer First extends boolean, ...infer Rest extends boolean[]]
+  ? (First extends Value ? Index['length'] : InternalBooleanFindIndex<Rest, Value, [...Index, unknown]>)
+  : -1
+/**
+ * Find the index of the first occurrence of a boolean value in a tuple.
+ *
+ * @example
+ * ```
+ * // Expect: 1
+ * type Example1 = BooleanFindIndex<[false, true, false], true>
+ * // Expect: 0
+ * type Example2 = BooleanFindIndex<[false, true, false], false>
+ * // Expect: -1
+ * type Example3 = BooleanFindIndex<[false, false], true>
+ * ```
+ */
+export type BooleanFindIndex<T extends readonly boolean[], Value extends boolean> =
+  InternalBooleanFindIndex<T, Value>
+
+// ============================================================================
+// Manipulation
+// ============================================================================
+
+/**
+ * Logical NOT operation.
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * type Example1 = BooleanNot<false>
+ * // Expect: false
+ * type Example2 = BooleanNot<true>
+ * ```
+ */
+export type BooleanNot<T extends boolean> = T extends true ? false : true
+
+/**
+ * Logical AND operation.
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * type Example1 = BooleanAnd<true, true>
+ * // Expect: false
+ * type Example2 = BooleanAnd<true, false>
+ * // Expect: false
+ * type Example3 = BooleanAnd<false, true>
+ * // Expect: false
+ * type Example4 = BooleanAnd<false, false>
+ * ```
+ */
+export type BooleanAnd<T extends boolean, U extends boolean> = T extends true ? (U extends true ? true : false) : false
+
+/**
+ * Logical NAND operation (NOT AND).
+ *
+ * @example
+ * ```
+ * // Expect: false
+ * type Example1 = BooleanNand<true, true>
+ * // Expect: true
+ * type Example2 = BooleanNand<true, false>
+ * // Expect: true
+ * type Example3 = BooleanNand<false, true>
+ * // Expect: true
+ * type Example4 = BooleanNand<false, false>
+ * ```
+ */
+export type BooleanNand<T extends boolean, U extends boolean> = T extends true ? (U extends true ? false : true) : true
+
+/**
+ * Logical OR operation.
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * type Example1 = BooleanOr<true, false>
+ * // Expect: false
+ * type Example2 = BooleanOr<false, false>
+ * // Expect: true
+ * type Example3 = BooleanOr<false, true>
+ * // Expect: true
+ * type Example4 = BooleanOr<true, true>
+ * ```
+ */
+export type BooleanOr<T extends boolean, U extends boolean> = T extends true ? true : (U extends true ? true : false)
+
+/**
+ * Logical NOR operation (NOT OR).
+ *
+ * @example
+ * ```
+ * // Expect: false
+ * type Example1 = BooleanNor<true, false>
+ * // Expect: true
+ * type Example2 = BooleanNor<false, false>
+ * // Expect: false
+ * type Example3 = BooleanNor<false, true>
+ * // Expect: false
+ * type Example4 = BooleanNor<true, true>
+ * ```
+ */
+export type BooleanNor<T extends boolean, U extends boolean> = T extends true ? false : (U extends true ? false : true)
+
+/**
+ * Logical XOR operation (exclusive OR).
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * type Example1 = BooleanXor<true, false>
+ * // Expect: false
+ * type Example2 = BooleanXor<false, false>
+ * // Expect: true
+ * type Example3 = BooleanXor<false, true>
+ * // Expect: false
+ * type Example4 = BooleanXor<true, true>
+ * ```
+ */
+export type BooleanXor<T extends boolean, U extends boolean> =
+  T extends true ? (U extends true ? false : true) : (U extends true ? true : false)
+
+/**
+ * Logical XNOR operation (exclusive NOR).
+ *
+ * @example
+ * ```
+ * // Expect: false
+ * type Example1 = BooleanXnor<true, false>
+ * // Expect: true
+ * type Example2 = BooleanXnor<false, false>
+ * // Expect: false
+ * type Example3 = BooleanXnor<false, true>
+ * // Expect: true
+ * type Example4 = BooleanXnor<true, true>
+ * ```
+ */
+export type BooleanXnor<T extends boolean, U extends boolean> =
+  T extends true ? (U extends true ? true : false) : (U extends true ? false : true)
+
+/**
+ * Check if all boolean values in a tuple are true.
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * type Example1 = BooleanAll<[true, true, true]>
+ * // Expect: false
+ * type Example2 = BooleanAll<[true, false, true]>
+ * // Expect: true
+ * type Example3 = BooleanAll<[]>
+ * ```
+ */
+export type BooleanAll<T extends readonly boolean[]> =
+  T extends [infer First extends boolean, ...infer Rest extends boolean[]]
+  ? (First extends true ? BooleanAll<Rest> : false)
+  : true
+
+/**
+ * Alias for BooleanAll.
+ */
+export type BooleanEvery<T extends readonly boolean[]> = BooleanAll<T>
+
+/**
+ * Check if any boolean value in a tuple is true.
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * type Example1 = BooleanAny<[false, true, false]>
+ * // Expect: false
+ * type Example2 = BooleanAny<[false, false, false]>
+ * // Expect: false
+ * type Example3 = BooleanAny<[]>
+ * ```
+ */
+export type BooleanAny<T extends readonly boolean[]> =
+  T extends [infer First extends boolean, ...infer Rest extends boolean[]]
+  ? (First extends true ? true : BooleanAny<Rest>)
+  : false
+
+/**
+ * Alias for BooleanAny.
+ */
+export type BooleanSome<T extends readonly boolean[]> = BooleanAny<T>
+
+/**
+ * Check if all boolean values in a tuple are false.
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * type Example1 = BooleanNone<[false, false, false]>
+ * // Expect: false
+ * type Example2 = BooleanNone<[false, true, false]>
+ * // Expect: true
+ * type Example3 = BooleanNone<[]>
+ * ```
+ */
+export type BooleanNone<T extends readonly boolean[]> =
+  T extends [infer First extends boolean, ...infer Rest extends boolean[]]
+  ? (First extends false ? BooleanNone<Rest> : false)
+  : true
+
+/**
+ * Filter a boolean tuple to keep only specified value (true or false).
+ *
+ * @example
+ * ```
+ * // Expect: [true, true]
+ * type Example1 = BooleanFilter<[true, false, true, false], true>
+ * // Expect: [false, false]
+ * type Example2 = BooleanFilter<[true, false, true, false], false>
+ * ```
+ */
+export type BooleanFilter<T extends readonly boolean[], Value extends boolean> =
+  T extends [infer First extends boolean, ...infer Rest extends boolean[]]
+  ? (First extends Value ? [First, ...BooleanFilter<Rest, Value>] : BooleanFilter<Rest, Value>)
+  : []
+
+/**
+ * Map a boolean tuple by applying NOT operation to each element.
+ *
+ * @example
+ * ```
+ * // Expect: [false, true, false]
+ * type Example1 = BooleanMapNot<[true, false, true]>
+ * ```
+ */
+export type BooleanMapNot<T extends readonly boolean[]> =
+  T extends [infer First extends boolean, ...infer Rest extends boolean[]]
+  ? [BooleanNot<First>, ...BooleanMapNot<Rest>]
+  : []
+
+type InternalBooleanReverse<T extends readonly boolean[], Acc extends readonly boolean[] = []> =
+  T extends [infer First extends boolean, ...infer Rest extends boolean[]]
+  ? InternalBooleanReverse<Rest, [First, ...Acc]>
+  : Acc
+/**
+ * Reverse a boolean tuple.
+ *
+ * @example
+ * ```
+ * // Expect: [false, true, true]
+ * type Example1 = BooleanReverse<[true, true, false]>
+ * ```
+ */
+export type BooleanReverse<T extends readonly boolean[]> = InternalBooleanReverse<T>
+
+/**
+ * Partition a boolean tuple into two groups: true values and false values.
+ *
+ * @example
+ * ```
+ * // Expect: [[true, true], [false, false]]
+ * type Example1 = BooleanPartition<[true, false, true, false]>
+ * ```
+ */
+export type BooleanPartition<T extends readonly boolean[]> = [BooleanFilter<T, true>, BooleanFilter<T, false>]
+
+/**
+ * Majority function - returns true if more than half of the values are true.
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * type Example1 = BooleanMajority<[true, true, false]>
+ * // Expect: false
+ * type Example2 = BooleanMajority<[true, false, false]>
+ * // Expect: false
+ * type Example3 = BooleanMajority<[true, false]>
+ * ```
+ */
+export type BooleanMajority<T extends readonly boolean[]> =
+  BooleanCountTrue<T> extends infer TrueCount extends number
+  ? (T['length'] extends infer Total extends number
+    ? (TrueCount extends 0 ? false : (Total extends 0 ? false :
+      // Compare TrueCount * 2 > Total by building arrays
+      [...InternalBuildArray<TrueCount>, ...InternalBuildArray<TrueCount>]['length'] extends infer Double extends number
+      ? (InternalIsGreaterThan<Double, Total> extends true ? true : false)
+      : false))
+    : false)
+  : false
+
+/**
+ * Parity function - returns true if an odd number of values are true.
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * type Example1 = BooleanParity<[true, false, false]>
+ * // Expect: false
+ * type Example2 = BooleanParity<[true, true, false]>
+ * // Expect: true
+ * type Example3 = BooleanParity<[true]>
+ * ```
+ */
+export type BooleanParity<T extends readonly boolean[]> =
+  T extends [infer First extends boolean, ...infer Rest extends boolean[]]
+  ? (First extends true ? BooleanNot<BooleanParity<Rest>> : BooleanParity<Rest>)
+  : false
+
+/**
+ * Threshold function - returns true if at least N values are true.
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * type Example1 = BooleanThreshold<[true, true, false], 2>
+ * // Expect: false
+ * type Example2 = BooleanThreshold<[true, false, false], 2>
+ * // Expect: true
+ * type Example3 = BooleanThreshold<[true, true, true], 2>
+ * ```
+ */
+export type BooleanThreshold<T extends readonly boolean[], N extends number> =
+  BooleanCountTrue<T> extends infer TrueCount extends number
+  ? (InternalBuildArray<TrueCount> extends [...InternalBuildArray<N>, ...unknown[]] ? true : false)
+  : false
+
+// ============================================================================
+// Boolean Conversion
+// ============================================================================
+
+/**
+ * Convert a boolean value to a number literal (true → 1, false → 0).
+ *
+ * @example
+ * ```
+ * // Expect: 1
+ * type Example1 = BooleanToNumber<true>
+ * // Expect: 0
+ * type Example2 = BooleanToNumber<false>
+ * ```
+ */
+export type BooleanToNumber<T extends boolean> = T extends true ? 1 : 0
+
+/**
+ * Convert a boolean value to a string literal.
+ *
+ * @example
+ * ```
+ * // Expect: 'true'
+ * type Example1 = BooleanToString<true>
+ * // Expect: 'false'
+ * type Example2 = BooleanToString<false>
+ * ```
+ */
+export type BooleanToString<T extends boolean> = T extends true ? 'true' : 'false'