@fxhash/params 0.0.4 → 0.0.7

package/dist/types.d.ts

@@ -0,0 +1,100 @@
+type FxParamType = "number" | "bigint" | "boolean" | "color" | "string" | "bytes" | "select";
+type FxParamOptionsMap = {
+    [Type in FxParamType]: {
+        number: {
+            min?: number;
+            max?: number;
+            step?: number;
+        };
+        bigint: {
+            min?: number | bigint;
+            max?: number | bigint;
+        };
+        boolean: undefined;
+        color: undefined;
+        string: {
+            minLength?: number;
+            maxLength?: number;
+        };
+        bytes: {
+            length: number;
+        };
+        select: {
+            options: string[];
+        };
+    }[Type];
+};
+type FxParamTypeMap = {
+    [Type in FxParamType]: {
+        number: number;
+        bigint: bigint;
+        boolean: boolean;
+        color: string;
+        string: string;
+        bytes: Uint8Array;
+        select: string;
+    }[Type];
+};
+type FxParamTransformationTypeMap = {
+    [Type in FxParamType]: {
+        number: number;
+        bigint: bigint;
+        boolean: boolean;
+        color: {
+            hex: {
+                rgb: string;
+                rgba: string;
+            };
+            obj: {
+                rgb: {
+                    r: number;
+                    g: number;
+                    b: number;
+                };
+                rgba: {
+                    r: number;
+                    g: number;
+                    b: number;
+                    a: number;
+                };
+            };
+            arr: {
+                rgb: [number, number, number];
+                rgba: [number, number, number, number];
+            };
+        };
+        string: string;
+        bytes: Uint8Array;
+        select: string;
+    }[Type];
+};
+type FxParamUpdateMode = "page-reload" | "sync" | "code-driven";
+type FxParamValue<Type extends FxParamType> = FxParamTypeMap[keyof FxParamTypeMap];
+interface FxParamDefinition<Type extends FxParamType> {
+    id: string;
+    name?: string;
+    type: Type;
+    update?: FxParamUpdateMode;
+    default: FxParamTypeMap[Type];
+    value: FxParamTypeMap[Type];
+    options: FxParamOptionsMap[Type];
+    version?: string;
+}
+type hexString = `#${string}`;
+type FxParamProcessorTransformer<Type extends FxParamType> = (value: FxParamTypeMap[Type], definition?: FxParamDefinition<Type>) => FxParamTransformationTypeMap[Type];
+type FxParamProcessorConstrainer<Type extends FxParamType> = (value: FxParamTypeMap[Type], definition?: FxParamDefinition<Type>) => FxParamTypeMap[Type];
+interface FxParamProcessor<Type extends FxParamType> {
+    serialize: (input: FxParamTypeMap[Type], definition: FxParamDefinition<Type>) => string;
+    deserialize: (input: string, definition: FxParamDefinition<Type>) => FxParamTypeMap[Type];
+    bytesLength: (definition: FxParamDefinition<Type>) => number;
+    transform?: FxParamProcessorTransformer<Type>;
+    constrain?: FxParamProcessorConstrainer<Type>;
+    random: (definition: FxParamDefinition<Type>) => FxParamTypeMap[Type];
+}
+type FxParamProcessors = {
+    [T in FxParamType]: FxParamProcessor<T>;
+};
+type FxParamTranformType = "transform" | "constrain";
+type FxParamsData = Record<string, any>;
+
+export { FxParamDefinition, FxParamOptionsMap, FxParamProcessor, FxParamProcessorConstrainer, FxParamProcessorTransformer, FxParamProcessors, FxParamTranformType, FxParamTransformationTypeMap, FxParamType, FxParamTypeMap, FxParamUpdateMode, FxParamValue, FxParamsData, hexString };

package/dist/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/utils.cjs

@@ -0,0 +1,33 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunk2QU65L2Ocjs = require('./chunk-2QU65L2O.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.MAX_SAFE_INT64 = _chunk2QU65L2Ocjs.MAX_SAFE_INT64; exports.MIN_SAFE_INT64 = _chunk2QU65L2Ocjs.MIN_SAFE_INT64; exports.ParameterProcessors = _chunk2QU65L2Ocjs.ParameterProcessors; exports.consolidateParams = _chunk2QU65L2Ocjs.consolidateParams; exports.deserializeParams = _chunk2QU65L2Ocjs.deserializeParams; exports.getRandomParamValues = _chunk2QU65L2Ocjs.getRandomParamValues; exports.hexToRgba = _chunk2QU65L2Ocjs.hexToRgba; exports.jsonStringifyBigint = _chunk2QU65L2Ocjs.jsonStringifyBigint; exports.processParam = _chunk2QU65L2Ocjs.processParam; exports.processParams = _chunk2QU65L2Ocjs.processParams; exports.rgbaToHex = _chunk2QU65L2Ocjs.rgbaToHex; exports.serializeParams = _chunk2QU65L2Ocjs.serializeParams; exports.stringifyParamsData = _chunk2QU65L2Ocjs.stringifyParamsData; exports.sumBytesParams = _chunk2QU65L2Ocjs.sumBytesParams;
+//# sourceMappingURL=utils.cjs.map

package/dist/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

package/dist/utils.d.ts

@@ -0,0 +1,50 @@
+import { hexString, FxParamProcessors, FxParamDefinition, FxParamType, FxParamTranformType, FxParamValue, FxParamsData, FxParamTransformationTypeMap } from './types.js';
+
+declare function rgbaToHex(r: number, g: number, b: number, a: number): string;
+declare function hexToRgba(hexCode: hexString): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+declare const MIN_SAFE_INT64: bigint;
+declare const MAX_SAFE_INT64: bigint;
+declare const ParameterProcessors: FxParamProcessors;
+declare function serializeParams(params: any, definition: FxParamDefinition<any>[]): string;
+declare function deserializeParams(bytes: string, definition: FxParamDefinition<FxParamType>[], options: {
+    withTransform?: boolean;
+    transformType?: FxParamTranformType;
+}): Record<string, {
+    hex: {
+        rgb: string;
+        rgba: string;
+    };
+    obj: {
+        rgb: {
+            r: number;
+            g: number;
+            b: number;
+        };
+        rgba: {
+            r: number;
+            g: number;
+            b: number;
+            a: number;
+        };
+    };
+    arr: {
+        rgb: [number, number, number];
+        rgba: [number, number, number, number];
+    };
+} | FxParamValue<Type>>;
+declare function consolidateParams(params: any, data: any): any[];
+declare function getRandomParamValues(params: FxParamDefinition<FxParamType>[], options?: {
+    noTransform: boolean;
+}): any;
+declare function sumBytesParams(definitions: FxParamDefinition<FxParamType>[]): number;
+declare function stringifyParamsData(data: FxParamsData): string;
+declare function jsonStringifyBigint(data: any): string;
+declare const processParam: (paramId: string, value: FxParamValue<FxParamType>, definitions: FxParamDefinition<FxParamType>[], transformType: FxParamTranformType) => FxParamValue<FxParamType> | FxParamTransformationTypeMap[FxParamType];
+declare const processParams: (values: FxParamsData, definitions: FxParamDefinition<FxParamType>[], transformType: FxParamTranformType) => {};
+
+export { MAX_SAFE_INT64, MIN_SAFE_INT64, ParameterProcessors, consolidateParams, deserializeParams, getRandomParamValues, hexToRgba, jsonStringifyBigint, processParam, processParams, rgbaToHex, serializeParams, stringifyParamsData, sumBytesParams };

package/dist/utils.js

@@ -0,0 +1,33 @@
+import {
+  MAX_SAFE_INT64,
+  MIN_SAFE_INT64,
+  ParameterProcessors,
+  consolidateParams,
+  deserializeParams,
+  getRandomParamValues,
+  hexToRgba,
+  jsonStringifyBigint,
+  processParam,
+  processParams,
+  rgbaToHex,
+  serializeParams,
+  stringifyParamsData,
+  sumBytesParams
+} from "./chunk-SDPENM2L.js";
+export {
+  MAX_SAFE_INT64,
+  MIN_SAFE_INT64,
+  ParameterProcessors,
+  consolidateParams,
+  deserializeParams,
+  getRandomParamValues,
+  hexToRgba,
+  jsonStringifyBigint,
+  processParam,
+  processParams,
+  rgbaToHex,
+  serializeParams,
+  stringifyParamsData,
+  sumBytesParams
+};
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/validation.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkEACKNC6Ccjs = require('./chunk-EACKNC6C.cjs');
+
+
+
+exports.BaseControllerDefinitionSchema = _chunkEACKNC6Ccjs.BaseControllerDefinitionSchema; exports.validateParameterDefinition = _chunkEACKNC6Ccjs.validateParameterDefinition;
+//# sourceMappingURL=validation.cjs.map

package/dist/validation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

package/dist/validation.d.ts

@@ -0,0 +1,241 @@
+import { z, SafeParseError, SafeParseSuccess } from 'zod';
+import { FxParamDefinition, FxParamType } from './types.js';
+
+declare const BaseControllerDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    exposedAsFeature: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    name?: string;
+    exposedAsFeature?: boolean;
+}, {
+    id?: string;
+    name?: string;
+    exposedAsFeature?: boolean;
+}>;
+declare const ControllerDefinitionSchema: z.ZodUnion<[z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    exposedAsFeature: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"string">;
+    options: z.ZodOptional<z.ZodObject<{
+        minLength: z.ZodOptional<z.ZodNumber>;
+        maxLength: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        minLength?: number;
+        maxLength?: number;
+    }, {
+        minLength?: number;
+        maxLength?: number;
+    }>>;
+    default: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    id?: string;
+    exposedAsFeature?: boolean;
+    type?: "string";
+    options?: {
+        minLength?: number;
+        maxLength?: number;
+    };
+    default?: string;
+}, {
+    name?: string;
+    id?: string;
+    exposedAsFeature?: boolean;
+    type?: "string";
+    options?: {
+        minLength?: number;
+        maxLength?: number;
+    };
+    default?: string;
+}>, z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    exposedAsFeature: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"number">;
+    options: z.ZodOptional<z.ZodObject<{
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        step: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        min?: number;
+        max?: number;
+        step?: number;
+    }, {
+        min?: number;
+        max?: number;
+        step?: number;
+    }>>;
+    default: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    id?: string;
+    exposedAsFeature?: boolean;
+    type?: "number";
+    options?: {
+        min?: number;
+        max?: number;
+        step?: number;
+    };
+    default?: number;
+}, {
+    name?: string;
+    id?: string;
+    exposedAsFeature?: boolean;
+    type?: "number";
+    options?: {
+        min?: number;
+        max?: number;
+        step?: number;
+    };
+    default?: number;
+}>, z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    exposedAsFeature: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"bigint">;
+    options: z.ZodOptional<z.ZodObject<{
+        min: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodBigInt]>>;
+        max: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodBigInt]>>;
+    }, "strip", z.ZodTypeAny, {
+        min?: number | bigint;
+        max?: number | bigint;
+    }, {
+        min?: number | bigint;
+        max?: number | bigint;
+    }>>;
+    default: z.ZodOptional<z.ZodBigInt>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    id?: string;
+    exposedAsFeature?: boolean;
+    type?: "bigint";
+    options?: {
+        min?: number | bigint;
+        max?: number | bigint;
+    };
+    default?: bigint;
+}, {
+    name?: string;
+    id?: string;
+    exposedAsFeature?: boolean;
+    type?: "bigint";
+    options?: {
+        min?: number | bigint;
+        max?: number | bigint;
+    };
+    default?: bigint;
+}>, z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    exposedAsFeature: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"select">;
+    options: z.ZodObject<{
+        options: z.ZodArray<z.ZodString, "atleastone">;
+    }, "strip", z.ZodTypeAny, {
+        options?: [string, ...string[]];
+    }, {
+        options?: [string, ...string[]];
+    }>;
+    default: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    id?: string;
+    exposedAsFeature?: boolean;
+    type?: "select";
+    options?: {
+        options?: [string, ...string[]];
+    };
+    default?: string;
+}, {
+    name?: string;
+    id?: string;
+    exposedAsFeature?: boolean;
+    type?: "select";
+    options?: {
+        options?: [string, ...string[]];
+    };
+    default?: string;
+}>, z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    exposedAsFeature: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"bytes">;
+    options: z.ZodObject<{
+        length: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        length?: number;
+    }, {
+        length?: number;
+    }>;
+    default: z.ZodOptional<z.ZodAny>;
+    update: z.ZodLiteral<"code-driven">;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    id?: string;
+    exposedAsFeature?: boolean;
+    type?: "bytes";
+    options?: {
+        length?: number;
+    };
+    default?: any;
+    update?: "code-driven";
+}, {
+    name?: string;
+    id?: string;
+    exposedAsFeature?: boolean;
+    type?: "bytes";
+    options?: {
+        length?: number;
+    };
+    default?: any;
+    update?: "code-driven";
+}>, z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    exposedAsFeature: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"boolean">;
+    options: z.ZodUndefined;
+    default: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    id?: string;
+    exposedAsFeature?: boolean;
+    type?: "boolean";
+    options?: undefined;
+    default?: boolean;
+}, {
+    name?: string;
+    id?: string;
+    exposedAsFeature?: boolean;
+    type?: "boolean";
+    options?: undefined;
+    default?: boolean;
+}>, z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    exposedAsFeature: z.ZodOptional<z.ZodBoolean>;
+    type: z.ZodLiteral<"color">;
+    options: z.ZodUndefined;
+    default: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    id?: string;
+    exposedAsFeature?: boolean;
+    type?: "color";
+    options?: undefined;
+    default?: string;
+}, {
+    name?: string;
+    id?: string;
+    exposedAsFeature?: boolean;
+    type?: "color";
+    options?: undefined;
+    default?: string;
+}>]>;
+type ControllerDefinitionSchemaType = z.infer<typeof ControllerDefinitionSchema>;
+declare function validateParameterDefinition(parameterDefinition: FxParamDefinition<FxParamType>): SafeParseError<ControllerDefinitionSchemaType> | SafeParseSuccess<ControllerDefinitionSchemaType> | undefined;
+
+export { BaseControllerDefinitionSchema, ControllerDefinitionSchemaType, validateParameterDefinition };

package/dist/validation.js

@@ -0,0 +1,9 @@
+import {
+  BaseControllerDefinitionSchema,
+  validateParameterDefinition
+} from "./chunk-MWP7SJWC.js";
+export {
+  BaseControllerDefinitionSchema,
+  validateParameterDefinition
+};
+//# sourceMappingURL=validation.js.map

package/dist/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fxhash/params",
-  "version": "0.0.4",
+  "version": "0.0.7",
   "author": "fxhash",
   "license": "MIT",
   "repository": {