@builder-builder/builder 0.0.6 → 0.0.8

package/dist/entities/option/select.js

@@ -0,0 +1,40 @@
+import * as v from 'valibot';
+import { serialisable } from '../../serialisable.js';
+export class BuilderSelectType {
+    type = 'select';
+    options;
+    valueSchema;
+    defaultValue;
+    isOptional;
+    optionLabels;
+    constructor(values, defaultValue, optional = false, optionLabels = {}) {
+        this.options = values;
+        const baseSchema = v.union(values.map((value) => v.literal(value)));
+        this.valueSchema = (optional ? v.nullable(baseSchema) : baseSchema);
+        this.defaultValue = defaultValue;
+        this.isOptional = optional;
+        this.optionLabels = optionLabels;
+    }
+    default(newDefault) {
+        return new BuilderSelectType(this.options, newDefault, this.isOptional, this.optionLabels);
+    }
+    optional() {
+        const { options, defaultValue } = this;
+        return new BuilderSelectType(options, defaultValue, true, this.optionLabels);
+    }
+    labels(optionLabels) {
+        return new BuilderSelectType(this.options, this.defaultValue, this.isOptional, optionLabels);
+    }
+}
+export function select(values) {
+    const [defaultValue] = values;
+    return new BuilderSelectType(values, defaultValue, false);
+}
+export const BuilderSelectTypeSchema = v.instance(BuilderSelectType);
+export const BuilderSelectTypeSerialisedSchema = serialisable(BuilderSelectType, v.object({
+    type: v.literal('select'),
+    options: v.pipe(v.tupleWithRest([v.string()], v.string()), v.readonly()),
+    defaultValue: v.nullable(v.string()),
+    isOptional: v.boolean(),
+    optionLabels: v.record(v.string(), v.string())
+}));

package/dist/entities/option/toggle.d.ts

@@ -0,0 +1,39 @@
+import type { BuilderPrimitive } from '../../primitive';
+import * as v from 'valibot';
+export declare const BuilderToggleValueTypeSchema: v.PicklistSchema<["string", "boolean", "number"], undefined>;
+export type BuilderToggleValueType = v.InferOutput<typeof BuilderToggleValueTypeSchema>;
+export declare class BuilderToggleType<const ValueSchema extends v.GenericSchema<BuilderPrimitive> = v.GenericSchema<BuilderPrimitive>> {
+    readonly value: v.InferOutput<ValueSchema>;
+    readonly type: "toggle";
+    readonly valueType: BuilderToggleValueType;
+    readonly valueSchema: ValueSchema;
+    readonly defaultValue: v.InferOutput<ValueSchema>;
+    readonly isOptional: boolean;
+    constructor(valueType: BuilderToggleValueType, defaultValue: v.InferOutput<ValueSchema>, optional?: boolean);
+    default(newDefault: v.InferOutput<ValueSchema>): BuilderToggleType<ValueSchema>;
+    optional(): BuilderToggleType<v.NullableSchema<ValueSchema, undefined>>;
+}
+export declare function toggleString(): BuilderToggleType<v.StringSchema<undefined>>;
+export declare function toggleBoolean(): BuilderToggleType<v.BooleanSchema<undefined>>;
+export declare function toggleNumber(): BuilderToggleType<v.NumberSchema<undefined>>;
+export declare const BuilderToggleTypeSchema: v.InstanceSchema<typeof BuilderToggleType, undefined>;
+export declare const BuilderToggleTypeSerialisedSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"toggle", undefined>;
+    readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
+    readonly defaultValue: v.NullableSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+    readonly isOptional: v.BooleanSchema<undefined>;
+}, undefined>, v.MetadataAction<{
+    type: "toggle";
+    valueType: "string" | "number" | "boolean";
+    defaultValue: string | number | boolean | null;
+    isOptional: boolean;
+}, {
+    readonly serialisable: typeof BuilderToggleType;
+    readonly instance: v.InstanceSchema<typeof BuilderToggleType, undefined>;
+}>, v.ReadonlyAction<{
+    type: "toggle";
+    valueType: "string" | "number" | "boolean";
+    defaultValue: string | number | boolean | null;
+    isOptional: boolean;
+}>]>;
+export type BuilderToggleTypeSerialised = v.InferOutput<typeof BuilderToggleTypeSerialisedSchema>;

package/dist/entities/option/toggle.js

@@ -0,0 +1,42 @@
+import * as v from 'valibot';
+import { serialisable } from '../../serialisable.js';
+export const BuilderToggleValueTypeSchema = v.picklist(['string', 'boolean', 'number']);
+export class BuilderToggleType {
+    type = 'toggle';
+    valueType;
+    valueSchema;
+    defaultValue;
+    isOptional;
+    constructor(valueType, defaultValue, optional) {
+        this.valueType = valueType;
+        this.valueSchema = deriveToggleValueSchema(valueType, optional || false);
+        this.defaultValue = defaultValue;
+        this.isOptional = optional || false;
+    }
+    default(newDefault) {
+        return new BuilderToggleType(this.valueType, newDefault, this.isOptional);
+    }
+    optional() {
+        return new BuilderToggleType(this.valueType, this.defaultValue, true);
+    }
+}
+export function toggleString() {
+    return new BuilderToggleType('string', '');
+}
+export function toggleBoolean() {
+    return new BuilderToggleType('boolean', false);
+}
+export function toggleNumber() {
+    return new BuilderToggleType('number', 0);
+}
+export const BuilderToggleTypeSchema = v.instance(BuilderToggleType);
+export const BuilderToggleTypeSerialisedSchema = serialisable(BuilderToggleType, v.object({
+    type: v.literal('toggle'),
+    valueType: BuilderToggleValueTypeSchema,
+    defaultValue: v.nullable(v.union([v.boolean(), v.string(), v.number()])),
+    isOptional: v.boolean()
+}));
+function deriveToggleValueSchema(valueType, optional) {
+    const baseSchema = valueType === 'string' ? v.string() : valueType === 'boolean' ? v.boolean() : v.number();
+    return optional ? v.nullable(baseSchema) : baseSchema;
+}

package/dist/entities/option/values.d.ts

@@ -0,0 +1,63 @@
+import * as v from 'valibot';
+import { BuilderSelectType } from './select.js';
+import { BuilderToggleType } from './toggle.js';
+export declare const BuilderOptionValuesSchema: v.UnionSchema<[v.InstanceSchema<typeof BuilderSelectType, undefined>, v.InstanceSchema<typeof BuilderToggleType, undefined>], undefined>;
+export type BuilderOptionValues = v.InferOutput<typeof BuilderOptionValuesSchema>;
+export declare const BuilderOptionValuesSerialisedSchema: v.SchemaWithPipe<readonly [v.VariantSchema<"type", [v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"select", undefined>;
+    readonly options: v.SchemaWithPipe<readonly [v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>, v.ReadonlyAction<[string, ...string[]]>]>;
+    readonly defaultValue: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+    readonly isOptional: v.BooleanSchema<undefined>;
+    readonly optionLabels: v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>;
+}, undefined>, v.MetadataAction<{
+    type: "select";
+    readonly options: readonly [string, ...string[]];
+    defaultValue: string | null;
+    isOptional: boolean;
+    optionLabels: {
+        [x: string]: string;
+    };
+}, {
+    readonly serialisable: typeof BuilderSelectType;
+    readonly instance: v.InstanceSchema<typeof BuilderSelectType, undefined>;
+}>, v.ReadonlyAction<{
+    type: "select";
+    readonly options: readonly [string, ...string[]];
+    defaultValue: string | null;
+    isOptional: boolean;
+    optionLabels: {
+        [x: string]: string;
+    };
+}>]>, v.SchemaWithPipe<readonly [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"toggle", undefined>;
+    readonly valueType: v.PicklistSchema<["string", "boolean", "number"], undefined>;
+    readonly defaultValue: v.NullableSchema<v.UnionSchema<[v.BooleanSchema<undefined>, v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>;
+    readonly isOptional: v.BooleanSchema<undefined>;
+}, undefined>, v.MetadataAction<{
+    type: "toggle";
+    valueType: "string" | "number" | "boolean";
+    defaultValue: string | number | boolean | null;
+    isOptional: boolean;
+}, {
+    readonly serialisable: typeof BuilderToggleType;
+    readonly instance: v.InstanceSchema<typeof BuilderToggleType, undefined>;
+}>, v.ReadonlyAction<{
+    type: "toggle";
+    valueType: "string" | "number" | "boolean";
+    defaultValue: string | number | boolean | null;
+    isOptional: boolean;
+}>]>], undefined>, v.ReadonlyAction<Readonly<{
+    type: "select";
+    readonly options: readonly [string, ...string[]];
+    defaultValue: string | null;
+    isOptional: boolean;
+    optionLabels: {
+        [x: string]: string;
+    };
+}> | Readonly<{
+    type: "toggle";
+    valueType: "string" | "number" | "boolean";
+    defaultValue: string | number | boolean | null;
+    isOptional: boolean;
+}>>]>;
+export type BuilderOptionValuesSerialised = v.InferOutput<typeof BuilderOptionValuesSerialisedSchema>;

package/dist/entities/option/values.js

@@ -0,0 +1,8 @@
+import * as v from 'valibot';
+import { BuilderSelectType, BuilderSelectTypeSerialisedSchema } from './select.js';
+import { BuilderToggleType, BuilderToggleTypeSerialisedSchema } from './toggle.js';
+export const BuilderOptionValuesSchema = v.union([
+    v.instance(BuilderSelectType),
+    v.instance(BuilderToggleType)
+]);
+export const BuilderOptionValuesSerialisedSchema = v.pipe(v.variant('type', [BuilderSelectTypeSerialisedSchema, BuilderToggleTypeSerialisedSchema]), v.readonly());

package/dist/entities/option/when.d.ts

@@ -0,0 +1,9 @@
+import type { Refable } from '../../references';
+import type { BuilderWhen } from '../when';
+import type { BuilderOptionValues } from './values';
+export type BuilderOptionWhen = BuilderWhen<Refable<BuilderOptionValues>>;
+export declare const optionWhen: {
+    enable: <const Values extends Refable<import("./select").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./toggle").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>>(values: Values) => import("../when").BuilderEnableConfig<Values>;
+    match: <const MatchPayload extends Refable<import("./select").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./toggle").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, const MatchPath extends Refable<import("../..").BuilderPath>, const SelectMap extends Refable<import("../when").BuilderMatchSelectMap<Refable<import("./select").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./toggle").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>>>>(matchPath: MatchPath, selectMap: SelectMap) => import("../when").BuilderMatchConfig<MatchPayload, MatchPath, SelectMap>;
+    unless: <const Values extends Refable<import("./select").BuilderSelectType<readonly [string, ...string[]], import("valibot").GenericSchema<string | null>> | import("./toggle").BuilderToggleType<import("valibot").GenericSchema<string | number | boolean | null>>>, const UnlessPath extends Refable<import("../..").BuilderPath>>(unlessPath: UnlessPath, disabledValues: import("../..").BuilderPrimitives, values: Values) => import("../when").BuilderUnlessConfig<Values, UnlessPath>;
+};

package/dist/entities/option/when.js

@@ -0,0 +1,2 @@
+import { createWhenFactories } from '../when.js';
+export const optionWhen = createWhenFactories();