types: remove type prefixes

packages/n4s/src/exports/compose.ts

@@ -1,16 +1,16 @@
 import invariant from 'invariant';
 import mapFirst from 'mapFirst';
 
-import type { TComposeResult, TLazyRuleRunners } from 'genEnforceLazy';
+import type { ComposeResult, LazyRuleRunners } from 'genEnforceLazy';
 import { ctx } from 'n4s';
-import { defaultToPassing, TRuleDetailedResult } from 'ruleReturn';
+import { defaultToPassing, RuleDetailedResult } from 'ruleReturn';
 import runLazyRule from 'runLazyRule';
 
 /* eslint-disable max-lines-per-function */
 
 export default function compose(
-  ...composites: TLazyRuleRunners[]
-): TComposeResult {
+  ...composites: LazyRuleRunners[]
+): ComposeResult {
   return Object.assign(
     (value: any) => {
       const res = run(value);
@@ -23,17 +23,17 @@ export default function compose(
     }
   );
 
-  function run(value: any): TRuleDetailedResult {
+  function run(value: any): RuleDetailedResult {
     return ctx.run({ value }, () => {
       return defaultToPassing(
         mapFirst(
           composites,
           (
-            composite: TLazyRuleRunners,
-            breakout: (res: TRuleDetailedResult) => void
+            composite: LazyRuleRunners,
+            breakout: (res: RuleDetailedResult) => void
           ) => {
             /* HACK: Just a small white lie. ~~HELP WANTED~~.
-               The ideal is that instead of `TLazyRuleRunners` We would simply use `TLazy` to begin with.
+               The ideal is that instead of `LazyRuleRunners` We would simply use `Lazy` to begin with.
                The problem is that lazy rules can't really be passed to this function due to some generic hell
                so we're limiting it to a small set of functions.
             */

packages/n4s/src/lib/eachEnforceRule.ts

@@ -1,9 +1,9 @@
 import isFunction from 'isFunction';
 
-import { baseRules, getRule, KBaseRules, TRuleBase } from 'runtimeRules';
+import { baseRules, getRule, KBaseRules, RuleBase } from 'runtimeRules';
 
 export default function eachEnforceRule(
-  action: (ruleName: KBaseRules, rule: TRuleBase) => void
+  action: (ruleName: KBaseRules, rule: RuleBase) => void
 ) {
   for (const ruleName in baseRules) {
     const ruleFn = getRule(ruleName);

packages/n4s/src/lib/ruleReturn.ts

@@ -1,11 +1,11 @@
 import defaultTo from 'defaultTo';
-import type { TStringable } from 'utilityTypes';
+import type { Stringable } from 'utilityTypes';
 
 export default function ruleReturn(
   pass: boolean,
   message?: string
-): TRuleDetailedResult {
-  const output: TRuleDetailedResult = { pass };
+): RuleDetailedResult {
+  const output: RuleDetailedResult = { pass };
 
   if (message) {
     output.message = message;
@@ -14,31 +14,31 @@ export default function ruleReturn(
   return output;
 }
 
-export function failing(): TRuleDetailedResult {
+export function failing(): RuleDetailedResult {
   return ruleReturn(false);
 }
 
-export function passing(): TRuleDetailedResult {
+export function passing(): RuleDetailedResult {
   return ruleReturn(true);
 }
 
 export function defaultToFailing(
-  callback: (...args: any[]) => TRuleDetailedResult
-): TRuleDetailedResult {
+  callback: (...args: any[]) => RuleDetailedResult
+): RuleDetailedResult {
   return defaultTo(callback, failing());
 }
 
 export function defaultToPassing(
-  callback: (...args: any[]) => TRuleDetailedResult
-): TRuleDetailedResult {
+  callback: (...args: any[]) => RuleDetailedResult
+): RuleDetailedResult {
   return defaultTo(callback, passing());
 }
 
-export type TRuleReturn =
+export type RuleReturn =
   | boolean
   | {
       pass: boolean;
-      message?: TStringable;
+      message?: Stringable;
     };
 
-export type TRuleDetailedResult = { pass: boolean; message?: string };
+export type RuleDetailedResult = { pass: boolean; message?: string };

packages/n4s/src/lib/runLazyRule.ts

@@ -1,11 +1,11 @@
-import type { TLazyRuleRunners } from 'genEnforceLazy';
-import type { TRuleDetailedResult } from 'ruleReturn';
+import type { LazyRuleRunners } from 'genEnforceLazy';
+import type { RuleDetailedResult } from 'ruleReturn';
 import * as ruleReturn from 'ruleReturn';
 
 export default function runLazyRule(
-  lazyRule: TLazyRuleRunners,
+  lazyRule: LazyRuleRunners,
   currentValue: any
-): TRuleDetailedResult {
+): RuleDetailedResult {
   try {
     return lazyRule.run(currentValue);
   } catch {

packages/n4s/src/lib/transformResult.ts

@@ -2,18 +2,18 @@ import invariant from 'invariant';
 import { isBoolean } from 'isBooleanValue';
 import optionalFunctionValue from 'optionalFunctionValue';
 
-import ruleReturn, { TRuleReturn, TRuleDetailedResult } from 'ruleReturn';
-import type { TRuleValue, TArgs } from 'runtimeRules';
+import ruleReturn, { RuleReturn, RuleDetailedResult } from 'ruleReturn';
+import type { RuleValue, Args } from 'runtimeRules';
 
 /**
  * Transform the result of a rule into a standard format
  */
 export function transformResult(
-  result: TRuleReturn,
+  result: RuleReturn,
   ruleName: string,
-  value: TRuleValue,
-  ...args: TArgs
-): TRuleDetailedResult {
+  value: RuleValue,
+  ...args: Args
+): RuleDetailedResult {
   validateResult(result);
 
   // if result is boolean
@@ -27,7 +27,7 @@ export function transformResult(
   }
 }
 
-function validateResult(result: TRuleReturn): void {
+function validateResult(result: RuleReturn): void {
   // if result is boolean, or if result.pass is boolean
   invariant(
     isBoolean(result) || (result && isBoolean(result.pass)),

packages/n4s/src/plugins/compounds/allOf.ts

@@ -1,11 +1,11 @@
 import mapFirst from 'mapFirst';
 
-import type { TLazy } from 'genEnforceLazy';
+import type { Lazy } from 'genEnforceLazy';
 import * as ruleReturn from 'ruleReturn';
-import type { TRuleDetailedResult } from 'ruleReturn';
+import type { RuleDetailedResult } from 'ruleReturn';
 import runLazyRule from 'runLazyRule';
 
-export function allOf(value: unknown, ...rules: TLazy[]): TRuleDetailedResult {
+export function allOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {
   return ruleReturn.defaultToPassing(
     mapFirst(rules, (rule, breakout) => {
       const res = runLazyRule(rule, value);

packages/n4s/src/plugins/compounds/anyOf.ts

@@ -1,11 +1,11 @@
 import mapFirst from 'mapFirst';
 
-import type { TLazy } from 'genEnforceLazy';
+import type { Lazy } from 'genEnforceLazy';
 import * as ruleReturn from 'ruleReturn';
-import type { TRuleDetailedResult } from 'ruleReturn';
+import type { RuleDetailedResult } from 'ruleReturn';
 import runLazyRule from 'runLazyRule';
 
-export function anyOf(value: unknown, ...rules: TLazy[]): TRuleDetailedResult {
+export function anyOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {
   return ruleReturn.defaultToFailing(
     mapFirst(rules, (rule, breakout) => {
       const res = runLazyRule(rule, value);

packages/n4s/src/plugins/compounds/noneOf.ts

@@ -1,11 +1,11 @@
 import mapFirst from 'mapFirst';
 
-import type { TLazy } from 'genEnforceLazy';
-import type { TRuleDetailedResult } from 'ruleReturn';
+import type { Lazy } from 'genEnforceLazy';
+import type { RuleDetailedResult } from 'ruleReturn';
 import * as ruleReturn from 'ruleReturn';
 import runLazyRule from 'runLazyRule';
 
-export function noneOf(value: unknown, ...rules: TLazy[]): TRuleDetailedResult {
+export function noneOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {
   return ruleReturn.defaultToPassing(
     mapFirst(rules, (rule, breakout) => {
       const res = runLazyRule(rule, value);

packages/n4s/src/plugins/compounds/oneOf.ts

@@ -1,13 +1,13 @@
-import type { TLazy } from 'genEnforceLazy';
+import type { Lazy } from 'genEnforceLazy';
 import { lengthEquals } from 'lengthEquals';
 import { longerThan } from 'longerThan';
-import ruleReturn, { TRuleDetailedResult } from 'ruleReturn';
+import ruleReturn, { RuleDetailedResult } from 'ruleReturn';
 import runLazyRule from 'runLazyRule';
 
 const REQUIRED_COUNT = 1;
 
-export function oneOf(value: unknown, ...rules: TLazy[]): TRuleDetailedResult {
-  const passing: TRuleDetailedResult[] = [];
+export function oneOf(value: unknown, ...rules: Lazy[]): RuleDetailedResult {
+  const passing: RuleDetailedResult[] = [];
   rules.some(rule => {
     if (longerThan(passing, REQUIRED_COUNT)) {
       return false;

packages/n4s/src/plugins/schema/isArrayOf.ts

@@ -1,15 +1,15 @@
 import mapFirst from 'mapFirst';
 
-import type { TLazyRuleRunners } from 'genEnforceLazy';
+import type { LazyRuleRunners } from 'genEnforceLazy';
 import { ctx } from 'n4s';
-import type { TRuleDetailedResult } from 'ruleReturn';
+import type { RuleDetailedResult } from 'ruleReturn';
 import * as ruleReturn from 'ruleReturn';
 import runLazyRule from 'runLazyRule';
 
 export function isArrayOf(
   inputArray: any[],
-  currentRule: TLazyRuleRunners
-): TRuleDetailedResult {
+  currentRule: LazyRuleRunners
+): RuleDetailedResult {
   return ruleReturn.defaultToPassing(
     mapFirst(inputArray, (currentValue, breakout, index) => {
       const res = ctx.run(

packages/n4s/src/plugins/schema/loose.ts

@@ -1,13 +1,13 @@
 import { ctx } from 'n4s';
-import type { TRuleDetailedResult } from 'ruleReturn';
+import type { RuleDetailedResult } from 'ruleReturn';
 import * as ruleReturn from 'ruleReturn';
 import runLazyRule from 'runLazyRule';
-import type { IShapeObject } from 'schemaTypes';
+import type { ShapeObject } from 'schemaTypes';
 
 export function loose(
   inputObject: Record<string, any>,
-  shapeObject: IShapeObject
-): TRuleDetailedResult {
+  shapeObject: ShapeObject
+): RuleDetailedResult {
   for (const key in shapeObject) {
     const currentValue = inputObject[key];
     const currentRule = shapeObject[key];

packages/n4s/src/plugins/schema/optional.ts

@@ -1,11 +1,11 @@
 import { isNullish } from 'isNullish';
 
-import type { TLazy } from 'genEnforceLazy';
-import type { TRuleDetailedResult } from 'ruleReturn';
+import type { Lazy } from 'genEnforceLazy';
+import type { RuleDetailedResult } from 'ruleReturn';
 import * as ruleReturn from 'ruleReturn';
 import runLazyRule from 'runLazyRule';
 
-export function optional(value: any, ruleChain: TLazy): TRuleDetailedResult {
+export function optional(value: any, ruleChain: Lazy): RuleDetailedResult {
   if (isNullish(value)) {
     return ruleReturn.passing();
   }

packages/n4s/src/plugins/schema/partial.ts

@@ -1,7 +1,7 @@
 import { enforce } from 'n4s';
 
 // Help needed improving the typings of this file.
-// Ideally, we'd be able to extend IShapeObject, but that's not possible.
+// Ideally, we'd be able to extend ShapeObject, but that's not possible.
 export function partial<T extends Record<any, any>>(shapeObject: T): T {
   const output = {} as T;
   for (const key in shapeObject) {

packages/n4s/src/plugins/schema/schemaTypes.ts

@@ -1,5 +1,5 @@
-import { TLazyRuleRunners } from 'genEnforceLazy';
+import { LazyRuleRunners } from 'genEnforceLazy';
 
-export interface IShapeObject
+export interface ShapeObject
   extends Record<string, any>,
-    Record<string, TLazyRuleRunners> {}
+    Record<string, LazyRuleRunners> {}

packages/n4s/src/plugins/schema/shape.ts

@@ -1,14 +1,14 @@
 import hasOwnProperty from 'hasOwnProperty';
 
 import { loose } from 'loose';
-import type { TRuleDetailedResult } from 'ruleReturn';
+import type { RuleDetailedResult } from 'ruleReturn';
 import * as ruleReturn from 'ruleReturn';
-import type { IShapeObject } from 'schemaTypes';
+import type { ShapeObject } from 'schemaTypes';
 
 export function shape(
   inputObject: Record<string, any>,
-  shapeObject: IShapeObject
-): TRuleDetailedResult {
+  shapeObject: ShapeObject
+): RuleDetailedResult {
   const baseRes = loose(inputObject, shapeObject);
   if (!baseRes.pass) {
     return baseRes;

packages/n4s/src/rules/isEven.ts

@@ -1,10 +1,10 @@
 import { isNumeric } from 'isNumeric';
-import type { TRuleValue } from 'runtimeRules';
+import type { RuleValue } from 'runtimeRules';
 
 /**
  * Validates that a given value is an even number
  */
-export const isEven = (value: TRuleValue): boolean => {
+export const isEven = (value: RuleValue): boolean => {
   if (isNumeric(value)) {
     return value % 2 === 0;
   }

packages/n4s/src/rules/isOdd.ts

@@ -1,9 +1,9 @@
 import { isNumeric } from 'isNumeric';
-import type { TRuleValue } from 'runtimeRules';
+import type { RuleValue } from 'runtimeRules';
 /**
  * Validates that a given value is an odd number
  */
-export const isOdd = (value: TRuleValue): boolean => {
+export const isOdd = (value: RuleValue): boolean => {
   if (isNumeric(value)) {
     return value % 2 !== 0;
   }

packages/n4s/src/rules/ruleCondition.ts

@@ -1,9 +1,9 @@
-import type { TRuleReturn } from 'ruleReturn';
+import type { RuleReturn } from 'ruleReturn';
 
 export function condition(
   value: any,
-  callback: (value: any) => TRuleReturn
-): TRuleReturn {
+  callback: (value: any) => RuleReturn
+): RuleReturn {
   try {
     return callback(value);
   } catch {