@bemedev/typings 1.1.3 → 1.1.5

package/README.md

@@ -40,6 +40,52 @@ expectTypeOf(result).toEqualTypeOf<{
 
 <br/>
 
+## Pre-processing Types with `pretype`
+
+The `pretype` function allows you to pre-process type definitions before
+transformation, enabling type context chaining and reusable type pipelines:
+
+```ts
+import { type, pretype } from '@bemedev/typings';
+
+const baseType = type(({ partial, record, primitiveObject }) =>
+  partial({
+    emitters: record({
+      next: primitiveObject.const,
+      error: primitiveObject.const,
+    }),
+    children: record(primitiveObject.map.const),
+  }),
+);
+
+const pretypedResult = pretype(baseType);
+
+// Access the pre-processed type context
+const finalType = pretypedResult({
+  emitters: {
+    data: { next: 'string', error: 'string' },
+  },
+  children: { eventMap: 'string' },
+});
+
+expectTypeOf(finalType.type).toEqualTypeOf<{
+  emitters?: { data: { next: string; error: string } };
+  children?: { eventMap: string };
+}>();
+
+// The pretype result includes the original type definition
+expectTypeOf(pretypedResult.pretype).toEqualTypeOf(baseType);
+```
+
+N.B. The `pretype` function is designed to work with the type definitions
+created using the `type` function, allowing you to create complex type
+transformations while maintaining access to the original type context for
+further processing or reuse. Also `pretype.pretype` is a getter to the
+original type definition, which can be useful for chaining or referencing
+the base type in multiple transformations.
+
+<br/>
+
 ## Available Helpers
 
 - `any`: Any type

package/lib/type.cjs

@@ -52,7 +52,10 @@ const type = (option) => {
 	else out = _transform(option);
 	return require_standard.standardize(out);
 };
-const pretype = (_) => require_utils_expandFn.expandFn(type, { type });
+const pretype = (pretype) => require_utils_expandFn.expandFn(type, {
+	type,
+	pretype: require_standard.standardize(pretype?.__type ?? "any")
+});
 //#endregion
 exports.pretype = pretype;
 exports.type = type;

package/lib/type.d.ts

@@ -25,6 +25,7 @@ export type Transform_F = <T extends ObjectT = ObjectT>(option?: ((helpers: Help
 type _PreTransform_F<U extends ObjectT> = <T extends SafePre<U> = SafePre<U>>(option?: ((helpers: Helpers) => T) | T) => inferSh<T>;
 export type PreTransform_F = <U extends ObjectT>(_?: inferSh<U>) => FnBasic<_PreTransform_F<U>, {
     type: _PreTransform_F<U>;
+    pretype: inferSh<U>;
 }>;
 export declare const type: Transform_F;
 export declare const pretype: PreTransform_F;

package/lib/type.js

@@ -51,6 +51,9 @@ const type = (option) => {
 	else out = _transform(option);
 	return standardize(out);
 };
-const pretype = (_) => expandFn(type, { type });
+const pretype = (pretype) => expandFn(type, {
+	type,
+	pretype: standardize(pretype?.__type ?? "any")
+});
 //#endregion
 export { pretype, type };

package/lib/types.d.ts

@@ -66,7 +66,7 @@ export type IntersectionCustom<T extends ObjectMapS[]> = T extends [
     ...infer Rest extends ObjectMapS[]
 ] ? First & IntersectionCustom<Rest> : unknown;
 type _ObjectT = __ObjectT | Optional | ArrayCustom;
-export type PrimitiveObjectT = SoRa<Types | (PrimitiveObjectMapS & Partial<Record<typeof PARTIAL, never>>) | ArrayCustom<Types | PrimitiveObjectMapS> | Optional<Types | PrimitiveObjectMapS> | UnionCustom<Types[] | PrimitiveObjectMapS[]> | PartialCustom<PrimitiveObjectMapS>>;
+export type PrimitiveObjectT = SoRa<PrimitiveT | PrimitiveObjectMapS | ArrayCustom<PrimitiveT | PrimitiveObjectMapS> | Optional<PrimitiveT | PrimitiveObjectMapS> | UnionCustom<(PrimitiveObjectMapS | PrimitiveT)[]> | PartialCustom<PrimitiveObjectMapS>>;
 export interface PrimitiveObjectMapS {
     [key: Keys]: PrimitiveObjectT;
 }
@@ -87,16 +87,16 @@ type ReduceTupleU<T extends AnyArray> = T extends [
 ] ? [Undefiny<First>, ...ReduceTupleU<Rest>] : T[number] extends never ? [] : T['length'] extends 0 ? [] : number extends T['length'] ? T : Undefiny<T[number]>[];
 type EmptyObject = {};
 type __TransformUnion<T extends UnionCustom> = T extends UnionCustom<infer TCustom> ? Omit<T, typeof UNION> extends infer Ot ? Equals<Ot, EmptyObject> extends true ? TransformT<TCustom[number]> : TransformT<TCustom[number]> & TransformT<Ot> : never : never;
-type HasUndefined<T> = unknown extends T ? false : OptionalHelperClass extends T ? true : false;
+type HasUndefined<T> = unknown extends T ? false : EmptyObject extends T ? false : OptionalHelperClass extends T ? true : false;
 type UndefinyObject<T extends object> = {
     [K in keyof T as HasUndefined<T[K]> extends true ? never : K]: Undefiny<T[K]>;
 } & {
     [K in keyof T as HasUndefined<T[K]> extends true ? K : never]?: Undefiny<T[K]>;
-} extends infer F ? {
-    [K in keyof F]: F[K];
+} extends infer O ? {
+    [K in keyof O]: O[K];
 } : never;
-type Undefiny<T, U = Exclude<T, OptionalHelperClass>> = U extends AnyArray ? ReduceTupleU<U> : U extends Ru ? UndefinyObject<U> : U;
-type TransformT<T> = Equals<ObjectMapS, T> extends true ? object : T extends Types ? TransformTypes<T> : T extends ArrayCustom<infer A> ? TransformT<A>[] : T extends UnionCustom ? __TransformUnion<T> : T extends SoRaCustom<infer TSoA> ? SoRa<TransformT<TSoA>> : T extends SoaCustom<infer TSoA> ? SoA<TransformT<TSoA>> : T extends Custom<infer TCustom> ? TCustom : T extends AnyArray<ObjectT> ? ReduceTuple2<T> : T extends PartialCustom<infer TPartial> ? Partial<TransformT<TPartial>> : T extends Optional<infer TOptional> ? TransformT<TOptional> | OptionalHelperClass : Undefiny<{
+type Undefiny<T, U = Exclude<T, OptionalHelperClass>> = U extends AnyArray ? ReduceTupleU<U> : U extends TrueObject ? UndefinyObject<U> : U;
+type TransformT<T> = EmptyObject extends T ? EmptyObject : Equals<ObjectMapS, T> extends true ? object : T extends Types ? TransformTypes<T> : T extends ArrayCustom<infer A> ? TransformT<A>[] : T extends UnionCustom ? __TransformUnion<T> : T extends SoRaCustom<infer TSoA> ? SoRa<TransformT<TSoA>> : T extends SoaCustom<infer TSoA> ? SoA<TransformT<TSoA>> : T extends Custom<infer TCustom> ? TCustom : T extends AnyArray<ObjectT> ? ReduceTuple2<T> : T extends PartialCustom<infer TPartial> ? Partial<TransformT<TPartial>> : T extends Optional<infer TOptional> ? TransformT<TOptional> | OptionalHelperClass : Undefiny<{
     [K in keyof T]: TransformT<T[K]>;
 }>;
 export type StandardHelper<T1 = any, T2 = any> = {
@@ -112,7 +112,11 @@ export type StandardOutput<T = any> = {
         };
     };
 };
-export type inferO<T extends ObjectT = ObjectT> = ObjectT extends T ? unknown : T extends Optional<infer U> ? TransformT<U> | undefined : TransformT<T>;
+export type PrimitiveObject = SoRa<Primitive | PrimitiveObjectMap>;
+export interface PrimitiveObjectMap {
+    [key: Keys]: PrimitiveObject;
+}
+export type inferO<T extends ObjectT = ObjectT> = EmptyObject extends T ? EmptyObject : PrimitiveObjectT extends T ? PrimitiveObject : T extends Optional<infer U> ? TransformT<U> | undefined : TransformT<T>;
 export type inferSh<T extends ObjectT = ObjectT> = _Sh<T, inferO<T>>;
 export type inferT<T extends StandardOutput = StandardOutput> = Exclude<T[typeof STANDARD_KEY]['types'], undefined>['output'];
 export type ProduceObject<T extends ObjectT = ObjectT> = T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bemedev/typings",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Typings by variables",
   "author": {
     "email": "bri_lvi@icloud.com",
@@ -69,7 +69,7 @@
   },
   "scripts": {
     "build": "pnpm rm:lib && pnpm run rolldown",
-    "_ci": "pnpm run config:off && pnpm run lint && pnpm run test",
+    "_ci": "pnpm clean --lockfile && pnpm run config:off && pnpm run lint && pnpm run test",
     "ci": "CI_START=$(date +%s) && pnpm run _ci && pnpm run p-q && echo \"\n✅ CI takes $(($(date +%s) - CI_START))s\n\"",
     "ci:admin": "CI_START=$(date +%s) && pnpm run rm && pnpm run upgrade:fast && pnpm run _ci && echo \"\n✅ Admin CI takes $(($(date +%s) - CI_START))s\n\"",
     "clean": "pnpm run rm && pnpm run config",