@bemedev/typings 1.1.2 → 1.1.4

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

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_standard = require("./standard.cjs");
+const require_utils_expandFn = require("./utils/expandFn.cjs");
 const require_helpers_any = require("./helpers/any.cjs");
 const require_helpers_array = require("./helpers/array.cjs");
 const require_helpers_custom = require("./helpers/custom.cjs");
@@ -51,7 +52,10 @@ const type = (option) => {
 	else out = _transform(option);
 	return require_standard.standardize(out);
 };
-const pretype = (_) => 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

@@ -1,5 +1,5 @@
-import type { inferSh, ObjectT } from './types';
-import { any, array, custom, intersection, litterals, object, omit, optional, partial, primitive, primitiveObject, readonly, record, soa, sv, tuple, union, sora, use } from './helpers';
+import type { FnBasic, inferSh, ObjectT, SafePre } from './types';
+import { any, array, custom, intersection, litterals, object, omit, optional, partial, primitive, primitiveObject, readonly, record, soa, sora, sv, tuple, union, use } from './helpers';
 type Helpers = {
     any: typeof any;
     custom: typeof custom;
@@ -22,10 +22,11 @@ type Helpers = {
     sora: typeof sora;
 };
 export type Transform_F = <T extends ObjectT = ObjectT>(option?: ((helpers: Helpers) => T) | T) => inferSh<T>;
-export type PreTransform = <U extends ObjectT>(_?: inferSh<U>) => {
-    <T extends U = U>(option?: ((helpers: Helpers) => T) | T): inferSh<T>;
-    type: <T extends U = U>(option?: ((helpers: Helpers) => T) | T) => inferSh<T>;
-};
+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;
+export declare const pretype: PreTransform_F;
 export {};

package/lib/type.js

@@ -1,4 +1,5 @@
 import { standardize } from "./standard.js";
+import { expandFn } from "./utils/expandFn.js";
 import { any } from "./helpers/any.js";
 import { array } from "./helpers/array.js";
 import { custom } from "./helpers/custom.js";
@@ -50,6 +51,9 @@ const type = (option) => {
 	else out = _transform(option);
 	return standardize(out);
 };
-const pretype = (_) => type;
+const pretype = (pretype) => expandFn(type, {
+	type,
+	pretype: standardize(pretype?.__type ?? "any")
+});
 //#endregion
 export { pretype, type };

package/lib/types.d.ts

@@ -117,4 +117,12 @@ 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;
 export type FnBasic<Main extends Fn, Tr extends object> = Tr & Main;
+type ReduceTupleSafePre<T extends ReadonlyArray<ObjectT>> = T extends readonly [
+    infer First extends ObjectT,
+    ...infer Rest extends ReadonlyArray<ObjectT>
+] ? readonly [SafePre<First>, ...ReduceTupleSafePre<Rest>] : [];
+type _SafePre<T extends ObjectT> = PrimitiveObjectT extends T ? PrimitiveObjectT : PrimitiveT extends T ? PrimitiveT : T extends Types ? T : T extends PartialCustom<infer TPartial> ? Partial<SafePre<TPartial>> : T extends ArrayCustom<infer A> ? SafePre<A>[] : T extends Optional<infer TOptional> ? SafePre<TOptional> | undefined : T extends SoRaCustom<infer TSoRa> ? SoRa<SafePre<TSoRa>> : T extends SoaCustom<infer TSoA> ? SoA<SafePre<TSoA>> : T extends Custom ? T : T extends AnyArray<ObjectT> ? ReduceTupleSafePre<T> : PrimitiveObjectMapS extends T ? PrimitiveObjectMapS : ObjectMapS extends T ? ObjectMapS : T extends ObjectMapS ? {
+    [K in keyof T]: SafePre<T[K]>;
+} : T;
+export type SafePre<T extends ObjectT> = Extract<_SafePre<T>, ObjectT>;
 export * from './standard.types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bemedev/typings",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "Typings by variables",
   "author": {
     "email": "bri_lvi@icloud.com",