@bemedev/typings 0.5.0 → 0.5.2

package/README.md

@@ -5,7 +5,7 @@ Typings by variables
 ## Usage
 
 ```ts
-import { type } from "@bemedev/typings";
+import { type } from '@bemedev/typings';
 
 const result = type(({ array, optional, intersection }) => ({
   nodes: optional(
@@ -13,16 +13,16 @@ const result = type(({ array, optional, intersection }) => ({
       intersection(
         {
           position: {
-            x: "number",
-            y: "number",
+            x: 'number',
+            y: 'number',
           },
           data: {
-            label: optional("string"),
-            content: "string",
+            label: optional('string'),
+            content: 'string',
           },
-          input: "boolean",
+          input: 'boolean',
         },
-        { id: "string" },
+        { id: 'string' },
       ),
     ),
   ),

package/lib/helpers/any.d.ts

@@ -1,4 +1,4 @@
-import type { NotReadonly, ObjectT } from "../types";
+import type { NotReadonly, ObjectT } from '../types';
 export declare const any: import("..").FnBasic<(<const T extends ObjectT = ObjectT>(value?: T) => ObjectT extends NotReadonly<T> ? "any" : NotReadonly<T>), object & {
     const: "any";
     type: "any";

package/lib/helpers/array.d.ts

@@ -1,4 +1,4 @@
-import type { ArrayCustom, ObjectT } from "../types";
+import type { ArrayCustom, ObjectT } from '../types';
 export declare const array: import("..").FnBasic<(<T extends ObjectT>(value: T) => ArrayCustom<T>), object & {
     const: ArrayCustom;
     type: ArrayCustom;

package/lib/helpers/custom.d.ts

@@ -1,4 +1,4 @@
-import type { Custom, ObjectT } from "../types";
+import type { Custom, ObjectT } from '../types';
 /**
  *  Create a custom value that can be used in the state value or as a literal.
  * @param value The value to create the custom value from.

package/lib/helpers/index.d.ts

@@ -1,16 +1,16 @@
-export * from "./any";
-export * from "./array";
-export * from "./custom";
-export * from "./intersection";
-export * from "./litterals";
-export * from "./optional";
-export * from "./partial";
-export * from "./primitive";
-export * from "./primitiveObject";
-export * from "./readonly";
-export * from "./record";
-export * from "./soa";
-export * from "./sv";
-export * from "./tuple";
-export * from "./union";
-export * from "./object";
+export * from './any';
+export * from './array';
+export * from './custom';
+export * from './intersection';
+export * from './litterals';
+export * from './optional';
+export * from './partial';
+export * from './primitive';
+export * from './primitiveObject';
+export * from './readonly';
+export * from './record';
+export * from './soa';
+export * from './sv';
+export * from './tuple';
+export * from './union';
+export * from './object';

package/lib/helpers/intersection.d.ts

@@ -1,2 +1,2 @@
-import type { IntersectionCustom, NotReadonly, ObjectMapS } from "../types";
+import type { IntersectionCustom, NotReadonly, ObjectMapS } from '../types';
 export declare const intersection: <const T extends [ObjectMapS, ObjectMapS, ...ObjectMapS[]]>(...values: T) => IntersectionCustom<NotReadonly<T>>;

package/lib/helpers/litterals.d.ts

@@ -1,4 +1,4 @@
-import type { Custom } from "../types";
+import type { Custom } from '../types';
 export declare const litterals: import("..").FnBasic<(<const T extends (string | number | boolean)[]>(...values: T) => Custom<T[number]>), object & {
     const: "string" | "number" | "boolean";
     type: "string" | "number" | "boolean";

package/lib/helpers/object.d.ts

@@ -1,4 +1,4 @@
-import type { NotReadonly, ObjectMapS } from "../types";
+import type { NotReadonly, ObjectMapS } from '../types';
 export declare const object: import("..").FnBasic<(<const T extends ObjectMapS>(value?: T) => ObjectMapS extends NotReadonly<T> ? ObjectMapS : NotReadonly<T>), object & {
     const: ObjectMapS;
     type: ObjectMapS;

package/lib/helpers/optional.d.ts

@@ -1,2 +1,2 @@
-import type { CanOptional, NotReadonly, Optional } from "../types";
+import type { CanOptional, NotReadonly, Optional } from '../types';
 export declare const optional: <const T extends CanOptional>(value?: T) => Optional<NotReadonly<T>>;

package/lib/helpers/partial.d.ts

@@ -1,2 +1,2 @@
-import type { NotReadonly, ObjectT, PartialCustom } from "../types";
+import type { NotReadonly, ObjectT, PartialCustom } from '../types';
 export declare const partial: <const T extends ObjectT>(value: T) => NotReadonly<T> & PartialCustom;

package/lib/helpers/primitive.d.ts

@@ -1,4 +1,4 @@
-import type { Custom, PrimitiveT } from "../types";
+import type { Custom, PrimitiveT } from '../types';
 export declare const primitive: import("..").FnBasic<(<const T extends PrimitiveT>(value?: T) => T), {
     readonly boolean: import("..").FnBasic<(<const T extends boolean>(value?: T) => boolean extends T ? "boolean" : Custom<T>), object & {
         const: "boolean";

package/lib/helpers/primitiveObject.d.ts

@@ -1,4 +1,4 @@
-import type { IntersectionCustom, NotReadonly, PrimitiveObjectMapS, PrimitiveObjectT } from "../types";
+import type { IntersectionCustom, NotReadonly, PrimitiveObjectMapS, PrimitiveObjectT } from '../types';
 export declare const primitiveObject: import("..").FnBasic<(<const T extends PrimitiveObjectT | IntersectionCustom<PrimitiveObjectMapS[]> = PrimitiveObjectT>(value?: T) => NotReadonly<T>), {
     readonly map: import("..").FnBasic<(<const T extends PrimitiveObjectMapS | IntersectionCustom<PrimitiveObjectMapS[]> = PrimitiveObjectMapS>(value?: T) => NotReadonly<T>), object & {
         const: PrimitiveObjectMapS;

package/lib/helpers/readonly.d.ts

@@ -1,2 +1,2 @@
-import type { ObjectT } from "../types";
+import type { ObjectT } from '../types';
 export declare const readonly: <const T extends ObjectT>(value: T) => T;

package/lib/helpers/record.d.ts

@@ -1,4 +1,4 @@
-import type { Keys, ObjectT } from "../types";
+import type { Keys, ObjectT } from '../types';
 export declare const record: import("..").FnBasic<(<const K extends Keys[], V extends ObjectT>(value: V, ...keys: K) => Record<K[number] extends never ? string | number | symbol : K[number], V>), object & {
     const: import("..").ObjectMapS;
     type: import("..").ObjectMapS;

package/lib/helpers/soa.d.ts

@@ -1,2 +1,2 @@
-import type { NotReadonly, ObjectT, SoaCustom } from "../types";
+import type { NotReadonly, ObjectT, SoaCustom } from '../types';
 export declare const soa: <const T extends ObjectT>(value?: T) => ObjectT extends NotReadonly<T> ? "any" : SoaCustom<NotReadonly<T>>;

package/lib/helpers/sv.d.ts

@@ -1,4 +1,4 @@
-import type { Custom, StateValue } from "../types";
+import type { Custom, StateValue } from '../types';
 export declare const sv: import("..").FnBasic<(<const T extends StateValue = StateValue>(value?: T) => StateValue extends T ? Custom<StateValue> : Custom<T>), object & {
     const: Custom<StateValue>;
     type: Custom<StateValue>;

package/lib/helpers/tuple.d.ts

@@ -1,4 +1,4 @@
-import type { NotReadonly, ObjectT } from "../types";
+import type { NotReadonly, ObjectT } from '../types';
 export declare const tuple: import("..").FnBasic<(<const T extends [ObjectT, ...ObjectT[]]>(...values: T) => NotReadonly<T>), object & {
     const: import("..").ArrayCustom;
     type: import("..").ArrayCustom;

package/lib/helpers/union.d.ts

@@ -1,4 +1,4 @@
-import type { Keys, ObjectMapS, ObjectT } from "../types";
+import type { Keys, ObjectMapS, ObjectT } from '../types';
 type Discriminated<K extends Keys> = ObjectMapS & Record<K, ObjectT>;
 export declare const union: import("..").FnBasic<(<T extends [ObjectT, ObjectT, ...ObjectT[]]>(...values: T) => T[number]), {
     readonly discriminated: <const K extends Keys, T extends [Discriminated<K>, Discriminated<K>, ...Discriminated<K>[]]>(_key: K, ...values: T) => T[number];

package/lib/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./constants";
-export * from "./type";
-export * from "./types";
+export * from './constants';
+export * from './type';
+export * from './types';

package/lib/standard.d.ts

@@ -1,4 +1,4 @@
-import type { StandardSchemaV1 } from "./standard.types";
+import type { StandardSchemaV1 } from './standard.types';
 type Standardize_F = <T>(value: T) => {
     value: T;
 } & StandardSchemaV1<T, T>;

package/lib/standard.types.d.ts

@@ -1,7 +1,7 @@
 /** The Standard Schema interface. */
 export interface StandardSchemaV1<Input = unknown, Output = Input> {
     /** The Standard Schema properties. */
-    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
 }
 export declare namespace StandardSchemaV1 {
     /** The Standard Schema properties interface. */
@@ -9,7 +9,7 @@ export declare namespace StandardSchemaV1 {
         /** The version number of the standard. */
         readonly version: 1;
         /** The vendor name of the schema library. */
-        readonly vendor: "@bemedev/typings";
+        readonly vendor: '@bemedev/typings';
         /** Validates unknown input values. */
         readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
         /** Inferred types associated with the schema. */
@@ -53,7 +53,7 @@ export declare namespace StandardSchemaV1 {
         readonly output: Output;
     }
     /** Infers the input type of a Standard Schema. */
-    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
     /** Infers the output type of a Standard Schema. */
-    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
 }

package/lib/type.d.ts

@@ -1,2 +1,2 @@
-import type { Transform_F } from "./type.types";
+import type { Transform_F } from './type.types';
 export declare const type: Transform_F;

package/lib/type.types.d.ts

@@ -1,5 +1,5 @@
-import type { any, array, custom, intersection, litterals, optional, partial, primitive, primitiveObject, readonly, record, soa, sv, tuple, union, object } from "./helpers";
-import type { ObjectT, inferSh } from "./types";
+import type { any, array, custom, intersection, litterals, optional, partial, primitive, primitiveObject, readonly, record, soa, sv, tuple, union, object } from './helpers';
+import type { ObjectT, inferSh } from './types';
 export type Helpers = {
     any: typeof any;
     custom: typeof custom;

package/lib/types.d.ts

@@ -1,5 +1,5 @@
-import type { ARRAY, CUSTOM, OPTIONAL, PARTIAL, PRIMITIVES, PRIMITIVE_OBJECTS, SOA } from "./constants";
-import type { StandardSchemaV1 } from "./standard.types";
+import type { ARRAY, CUSTOM, OPTIONAL, PARTIAL, PRIMITIVES, PRIMITIVE_OBJECTS, SOA } from './constants';
+import type { StandardSchemaV1 } from './standard.types';
 export type Ru = Record<Keys, unknown>;
 export type TrueObject = Ru & {
     [Symbol.iterator]?: never;
@@ -27,9 +27,9 @@ export type SingleOrRecursiveArrayOf<T> = T | RecursiveArrayOf<T>;
 export type SoRa<T> = SingleOrRecursiveArrayOf<T>;
 export type Primitive = string | number | boolean | bigint | null | undefined | symbol | never;
 export type PrimitiveT = (typeof PRIMITIVES)[number];
-type TransformPrimitiveS<T extends PrimitiveT> = T extends "string" ? string : T extends "number" ? number : T extends "boolean" ? boolean : T extends "bigint" ? bigint : T extends "null" ? null : T extends "undefined" ? undefined : T extends "symbol" ? symbol : T extends "never" ? never : Primitive;
+type TransformPrimitiveS<T extends PrimitiveT> = T extends 'string' ? string : T extends 'number' ? number : T extends 'boolean' ? boolean : T extends 'bigint' ? bigint : T extends 'null' ? null : T extends 'undefined' ? undefined : T extends 'symbol' ? symbol : T extends 'never' ? never : Primitive;
 export type Types = PrimitiveT | (typeof PRIMITIVE_OBJECTS)[number];
-export type TransformTypes<T extends Types> = T extends PrimitiveT ? TransformPrimitiveS<T> : T extends "date" ? Date : T extends "any" ? any : T extends "unknown" ? unknown : object;
+export type TransformTypes<T extends Types> = T extends PrimitiveT ? TransformPrimitiveS<T> : T extends 'date' ? Date : T extends 'any' ? any : T extends 'unknown' ? unknown : object;
 export type Custom<T = any> = {
     [CUSTOM]: T;
 };
@@ -77,7 +77,7 @@ type ReduceTuple2<T extends AnyArray<ObjectT>> = T extends [
 type ReduceTupleU<T extends AnyArray> = T extends [
     infer First,
     ...infer Rest extends AnyArray
-] ? [Undefiny<First>, ...ReduceTupleU<Rest>] : T[number] extends never ? [] : T["length"] extends 0 ? [] : number extends T["length"] ? T : Undefiny<T[number]>[];
+] ? [Undefiny<First>, ...ReduceTupleU<Rest>] : T[number] extends never ? [] : T['length'] extends 0 ? [] : number extends T['length'] ? T : Undefiny<T[number]>[];
 type __TransformPrimitiveObject<T> = T extends Types ? TransformTypes<T> : T extends ArrayCustom<infer A> ? TransformT<A>[] : T extends SoaCustom<infer TSoA> ? SoA<__TransformPrimitiveObject<TSoA>> : T extends Custom<infer TCustom> ? TCustom : T extends AnyArray<ObjectT> ? ReduceTuple2<T> : T extends PartialCustom ? Partial<__TransformPrimitiveObject<NOmit<T, typeof PARTIAL>>> : T extends Optional<infer TOptional> ? __TransformPrimitiveObject<TOptional> | OptionalHelperClass : {
     [K in keyof T]: __TransformPrimitiveObject<T[K]>;
 };
@@ -95,10 +95,10 @@ export type StandardHelper<T = any> = {
     value: T;
 } & StandardSchemaV1<T, T>;
 export type Sh<T = any> = StandardHelper<T>;
-export type StandardOutput<T> = StandardSchemaV1<any, T>;
+export type StandardOutput<T = any> = StandardSchemaV1<any, T>;
 export type inferO<T extends ObjectT = ObjectT> = ObjectT extends T ? unknown : TransformT<T>;
 export type inferSh<T extends ObjectT = ObjectT> = Sh<inferO<T>>;
-export type inferT<T extends Sh> = T["value"];
+export type inferT<T extends StandardOutput = StandardOutput> = Exclude<T['~standard']['types'], undefined>['output'];
 export type ProduceObject<T extends ObjectT = ObjectT> = T;
 export type FnBasic<Main extends Fn, Tr extends object> = Tr & Main;
 export {};

package/lib/utils/expandFn.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, FnBasic, ObjectT } from "../types";
+import type { Fn, FnBasic, ObjectT } from '../types';
 export declare const expandFn: <Main extends Fn, const Tr extends object = object>(main: Main, extensions?: Tr) => FnBasic<Main, Tr>;
 export declare const expandFn2: <Main extends Fn, C extends ObjectT, const Tr extends object = object>(main: Main, type: C, extensions?: Tr) => FnBasic<Main, Tr & {
     const: C;

package/lib/utils/index.d.ts

@@ -1,3 +1,3 @@
-import type { ObjectT } from "../types";
-export * from "./expandFn";
+import type { ObjectT } from '../types';
+export * from './expandFn';
 export declare const _const: <T extends ObjectT>(value?: T) => T;

package/package.json

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