cleaned up tsconfig and lib

Author: dested

lib/schemaDefiner.d.ts

@@ -1,10 +1,17 @@
+import { SafeSchema } from './schemaDefinerTypes';
 import { ArrayBufferBuilder, ArrayBufferReader } from './arrayBufferBuilder';
+export declare type SchemaGenerator<T> = {
+    readerFunction: (reader: ArrayBufferReader) => T;
+    adderFunction: (buff: ArrayBufferBuilder, value: T) => ArrayBuffer;
+    adderSizeFunction: (value: T) => number;
+};
 export declare class SchemaDefiner {
     static generateAdderFunction(schema: any): any;
     static generateAdderSizeFunction(schema: any): any;
     static generateReaderFunction(schema: any): any;
-    static startAddSchemaBuffer(value: any, adderSizeFunction: (value: any) => number, adderFunction: (buff: ArrayBufferBuilder, value: any) => ArrayBuffer): ArrayBuffer;
-    static startReadSchemaBuffer(buffer: ArrayBuffer | ArrayBufferLike, readerFunction: (reader: ArrayBufferReader) => any): any;
+    static generate<T>(schema: SafeSchema<T>): SchemaGenerator<T>;
+    static toBuffer<T>(value: T, generator: SchemaGenerator<T>): ArrayBuffer;
+    static fromBuffer<T>(buffer: ArrayBuffer | ArrayBufferLike, generator: SchemaGenerator<T>): T;
     private static buildAdderFunction;
     private static buildAdderSizeFunction;
     private static buildReaderFunction;

lib/schemaDefiner.d.ts.map

@@ -1,56 +1,63 @@
-export declare type Discriminate<T, TField extends keyof T, TValue extends T[TField]> = T extends {
+declare type Discriminate<T, TField extends keyof T, TValue extends T[TField]> = T extends {
     [field in TField]: TValue;
 } ? T : never;
-export declare type SDEnum<T extends string> = {
+export declare type SafeSchemaEnum<T extends string> = {
     [key in T]: number;
 } & {
     flag: 'enum';
 };
-export declare type SDBitmask<T> = {
+export declare type SafeSchemaBitmask<T> = {
     [keyT in keyof T]-?: number;
 } & {
     flag: 'bitmask';
 };
-export declare type SDArray<TElements> = {
+export declare type SafeSchemaArray<TElements> = {
     elements: TElements;
     flag: 'array-uint8' | 'array-uint16';
 };
-export declare type SDTypeLookupElements<TElements extends {
+export declare type SafeSchemaTypeLookupElements<TElements extends {
     type: string;
 }> = {
     elements: {
-        [key in TElements['type']]: SDTypeLookup<TElements, key>;
+        [key in TElements['type']]: SafeSchemaTypeLookup<TElements, key>;
     };
     flag: 'type-lookup';
 };
-export declare type SDTypeLookup<TItem extends {
+export declare type SafeSchemaTypeLookup<TItem extends {
     type: string;
-}, TKey extends TItem['type']> = SDSimpleObject<Omit<Discriminate<TItem, 'type', TKey>, 'type'>>;
-export declare type SDTypeElement<TItem extends {
+}, TKey extends TItem['type']> = SafeSchemaSimpleObject<Omit<Discriminate<TItem, 'type', TKey>, 'type'>>;
+export declare type SafeSchemaTypeElement<TItem extends {
     type: string;
-}> = SDSimpleObject<Omit<TItem, 'type'>>;
-export declare type SDSimpleObject<TItem> = {
+}> = SafeSchemaSimpleObject<Omit<TItem, 'type'>>;
+export declare type SafeSchemaSimpleObject<TItem> = {
     [keyT in OptionalPropertyOf<TItem>]: {
-        element: SDElement<Required<TItem>, keyT>;
+        element: SafeSchemaElement<Required<TItem>, keyT>;
         flag: 'optional';
     };
 } & {
-    [keyT in RequiredPropertyOf<TItem>]: SDElement<Required<TItem>, keyT>;
+    [keyT in RequiredPropertyOf<TItem>]: SafeSchemaElement<Required<TItem>, keyT>;
 };
 declare type OptionalPropertyOf<T> = Exclude<{
     [K in keyof T]: T extends Record<K, T[K]> ? never : K;
 }[keyof T], undefined>;
 declare type RequiredPropertyOf<T> = Exclude<{
     [K in keyof T]: T extends Record<K, T[K]> ? K : never;
 }[keyof T], undefined>;
-declare type Simple<T> = T extends string ? 'string' | SDEnum<T> : T extends number ? 'uint8' | 'uint16' | 'uint32' | 'int8' | 'int16' | 'int32' | 'float32' | 'float64' : T extends boolean ? 'boolean' : never;
-export declare type SDElement<T, TKey extends keyof T> = T[TKey] extends string | boolean | number ? Simple<T[TKey]> : T[TKey] extends Array<any> ? T[TKey][number] extends string | boolean | number ? SDArray<Simple<T[TKey][number]>> : T[TKey][number] extends {
+declare type SafeSchemaSimple<T> = T extends string ? 'string' | SafeSchemaEnum<T> : T extends number ? 'uint8' | 'uint16' | 'uint32' | 'int8' | 'int16' | 'int32' | 'float32' | 'float64' : T extends boolean ? 'boolean' : never;
+export declare type SafeSchemaElement<T, TKey extends keyof T> = T[TKey] extends string | boolean | number ? SafeSchemaSimple<T[TKey]> : T[TKey] extends Array<any> ? T[TKey][number] extends string | boolean | number ? SafeSchemaArray<SafeSchemaSimple<T[TKey][number]>> : T[TKey][number] extends {
     type: string;
-} ? SDArray<SDTypeLookupElements<T[TKey][number]>> | SDArray<SDSimpleObject<T[TKey][number]>> : SDArray<SDSimpleObject<T[TKey][number]>> : T[TKey] extends {
+} ? SafeSchemaArray<SafeSchemaTypeLookupElements<T[TKey][number]>> | SafeSchemaArray<SafeSchemaSimpleObject<T[TKey][number]>> : SafeSchemaArray<SafeSchemaSimpleObject<T[TKey][number]>> : T[TKey] extends {
     [key in keyof T[TKey]]: boolean;
-} ? SDBitmask<T[TKey]> : T[TKey] extends {
+} ? SafeSchemaBitmask<T[TKey]> : T[TKey] extends {
     type: string;
-} ? SDTypeLookupElements<T[TKey]> | SDSimpleObject<T[TKey]> : T[TKey] extends {} ? SDSimpleObject<T[TKey]> : never;
+} ? SafeSchemaTypeLookupElements<T[TKey]> | SafeSchemaSimpleObject<T[TKey]> : T[TKey] extends {} ? SafeSchemaSimpleObject<T[TKey]> : never;
+export declare type SafeSchema<T> = T extends string | boolean | number ? SafeSchemaSimple<T> : T extends Array<any> ? T[number] extends string | boolean | number ? SafeSchemaArray<SafeSchemaSimple<T[number]>> : T[number] extends {
+    type: string;
+} ? SafeSchemaArray<SafeSchemaTypeLookupElements<T[number]>> | SafeSchemaArray<SafeSchemaSimpleObject<T[number]>> : SafeSchemaArray<SafeSchemaSimpleObject<T[number]>> : T extends {
+    [key in keyof T]: boolean;
+} ? SafeSchemaBitmask<T> | SafeSchemaSimpleObject<T> : T extends {
+    type: string;
+} ? SafeSchemaTypeLookupElements<T> | SafeSchemaSimpleObject<T> : T extends {} ? SafeSchemaSimpleObject<T> : never;
 export declare type ABFlags = {
     flag: 'enum';
 } | {

lib/schemaDefiner.js

@@ -1,14 +1,13 @@
 {
   "name": "safe-schema",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "author": "Salvatore <[email protected]>",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "publish-cli": "npm publish",
     "test": "jest",
     "build": "tsc"
   },

lib/schemaDefiner.js.map

@@ -1,12 +1,6 @@
 {
   "compileOnSave": true,
   "compilerOptions": {
-    "allowSyntheticDefaultImports": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "removeComments": false,
-    "allowUnreachableCode": true,
-    "allowJs": true,
     "declaration": true,
     "moduleResolution": "node",
     "target": "es2015",
@@ -18,12 +12,11 @@
     ],
     "outDir": "./lib/",
     "sourceMap": true,
-    "skipLibCheck": true,
-    "baseUrl": "./src",
-    "jsx": "react"
+    "baseUrl": "./src"
   },
   "exclude": [
     "lib",
+    "__tests__",
     "node_modules"
   ]
 }