alepha 0.13.6 → 0.13.7

package/dist/core/index.browser.js

@@ -1,9 +1,8 @@
 import { Compile } from "typebox/compile";
-import * as TypeBox from "typebox";
 import { Type } from "typebox";
-import TypeBoxFormat from "typebox/format";
+import Format from "typebox/format";
 import { Locale } from "typebox/system";
-import * as TypeBoxValue from "typebox/value";
+import * as Value from "typebox/value";
 
 //#region ../../src/core/constants/KIND.ts
 /**
@@ -697,7 +696,7 @@ var StateManager = class {
 		const key = atom.key;
 		if (!this.atoms.has(key)) {
 			this.atoms.set(key, atom);
-			if (!(key in this.store)) this.set(key, atom.options.default);
+			if (!(key in this.store)) this.set(key, atom.options.default, { skipContext: true });
 		}
 		return this;
 	}
@@ -707,15 +706,15 @@ var StateManager = class {
 		const store = this.store;
 		return this.als?.exists() ? this.als.get(key) ?? store[key] : store[key];
 	}
-	set(target, value) {
+	set(target, value, options) {
 		if (target instanceof Atom) this.register(target);
 		const key = target instanceof Atom ? target.key : target;
 		const store = this.store;
 		const prevValue = this.get(key);
 		if (prevValue === value) return this;
-		if (this.als?.exists()) this.als.set(key, value);
+		if (options?.skipContext !== true && this.als?.exists()) this.als.set(key, value);
 		else store[key] = value;
-		this.events?.emit("state:mutate", {
+		if (options?.skipEvents !== true) this.events?.emit("state:mutate", {
 			key,
 			value,
 			prevValue
@@ -741,9 +740,9 @@ var StateManager = class {
 	/**
 	* Push a value to an array in the state
 	*/
-	push(key, value) {
+	push(key, ...value) {
 		const current = this.get(key) ?? [];
-		if (Array.isArray(current)) this.set(key, [...current, value]);
+		if (Array.isArray(current)) this.set(key, [...current, ...value]);
 		return this;
 	}
 	/**
@@ -938,12 +937,6 @@ var Alepha = class Alepha {
 	*/
 	starting;
 	/**
-	* Initial state of the container.
-	*
-	* > Used to initialize the StateManager.
-	*/
-	init;
-	/**
 	* During the instantiation process, we keep a list of pending instantiations.
 	* > It allows us to detect circular dependencies.
 	*/
@@ -980,30 +973,21 @@ var Alepha = class Alepha {
 	*
 	* Mocked for browser environments.
 	*/
-	get context() {
-		return this.inject(AlsProvider);
-	}
+	context;
 	/**
 	* Event manager to handle lifecycle events and custom events.
 	*/
-	get events() {
-		return this.inject(EventManager, { args: [() => this.log] });
-	}
+	events;
 	/**
 	* State manager to store arbitrary values.
 	*/
-	get store() {
-		this.events;
-		return this.inject(StateManager, { args: [this.init] });
-	}
+	store;
 	/**
 	* Codec manager for encoding and decoding data with different formats.
 	*
 	* Supports multiple codec formats (JSON, Protobuf, etc.) with a unified interface.
 	*/
-	get codec() {
-		return this.inject(CodecManager);
-	}
+	codec;
 	/**
 	* Get logger instance.
 	*/
@@ -1016,8 +1000,12 @@ var Alepha = class Alepha {
 	get env() {
 		return this.store.get("env") ?? {};
 	}
-	constructor(init = {}) {
-		this.init = init;
+	constructor(state = {}) {
+		this.store = this.inject(StateManager, { args: [state] });
+		this.events = this.inject(EventManager);
+		this.events.logFn = () => this.log;
+		this.context = this.inject(AlsProvider);
+		this.codec = this.inject(CodecManager);
 	}
 	set(target, value) {
 		this.store.set(target, value);
@@ -1084,7 +1072,7 @@ var Alepha = class Alepha {
 	isServerless() {
 		if (this.isBrowser()) return false;
 		if (this.env.VERCEL_REGION) return true;
-		if (this.env.ALEPHA_SERVERLESS) return true;
+		if (typeof global === "object" && typeof global.Cloudflare === "object") return true;
 		return false;
 	}
 	/**
@@ -1122,7 +1110,6 @@ var Alepha = class Alepha {
 			this.log?.warn("App is already starting, waiting for it to finish...");
 			return this.starting.promise;
 		}
-		this.codec;
 		this.starting = Promise.withResolvers();
 		const now = Date.now();
 		this.log?.info("Starting App...");
@@ -1302,6 +1289,19 @@ var Alepha = class Alepha {
 		return config;
 	}
 	/**
+	* Get all environment variable schemas and their parsed values.
+	*
+	* This is useful for DevTools to display all expected environment variables.
+	*/
+	getEnvSchemas() {
+		const result = [];
+		for (const [schema, values] of this.cacheEnv.entries()) result.push({
+			schema,
+			values
+		});
+		return result;
+	}
+	/**
 	* Dump the current dependency graph of the App.
 	*
 	* This method returns a record where the keys are the names of the services.
@@ -1456,33 +1456,27 @@ const isFileLike = (value) => {
 
 //#endregion
 //#region ../../src/core/providers/TypeProvider.ts
-const isUUID = TypeBoxFormat.IsUuid;
-const isEmail = TypeBoxFormat.IsEmail;
-const isURL = TypeBoxFormat.IsUrl;
-const isDateTime = TypeBoxFormat.IsDateTime;
-const isDate = TypeBoxFormat.IsDate;
-const isTime = TypeBoxFormat.IsTime;
-const isDuration = TypeBoxFormat.IsDuration;
+const isUUID = Format.IsUuid;
 var TypeGuard = class {
-	isBigInt = (value) => TypeBox.IsString(value) && "format" in value && value.format === "bigint";
-	isUUID = (value) => TypeBox.IsString(value) && "format" in value && value.format === "uuid";
-	isObject = TypeBox.IsObject;
-	isNumber = TypeBox.IsNumber;
-	isString = TypeBox.IsString;
-	isBoolean = TypeBox.IsBoolean;
-	isAny = TypeBox.IsAny;
-	isArray = TypeBox.IsArray;
-	isOptional = TypeBox.IsOptional;
-	isUnion = TypeBox.IsUnion;
-	isInteger = TypeBox.IsInteger;
-	isNull = TypeBox.IsNull;
-	isUndefined = TypeBox.IsUndefined;
-	isUnsafe = TypeBox.IsUnsafe;
-	isRecord = TypeBox.IsRecord;
-	isTuple = TypeBox.IsTuple;
-	isVoid = TypeBox.IsVoid;
-	isLiteral = TypeBox.IsLiteral;
-	isSchema = TypeBox.IsSchema;
+	isBigInt = (value) => Type.IsString(value) && "format" in value && value.format === "bigint";
+	isUUID = (value) => Type.IsString(value) && "format" in value && value.format === "uuid";
+	isObject = Type.IsObject;
+	isNumber = Type.IsNumber;
+	isString = Type.IsString;
+	isBoolean = Type.IsBoolean;
+	isAny = Type.IsAny;
+	isArray = Type.IsArray;
+	isOptional = Type.IsOptional;
+	isUnion = Type.IsUnion;
+	isInteger = Type.IsInteger;
+	isNull = Type.IsNull;
+	isUndefined = Type.IsUndefined;
+	isUnsafe = Type.IsUnsafe;
+	isRecord = Type.IsRecord;
+	isTuple = Type.IsTuple;
+	isVoid = Type.IsVoid;
+	isLiteral = Type.IsLiteral;
+	isSchema = Type.IsSchema;
 	isFile = isTypeFile;
 	isDateTime = (schema) => {
 		return t.schema.isString(schema) && schema.format === "date-time";
@@ -1498,9 +1492,9 @@ var TypeGuard = class {
 	};
 };
 var TypeProvider = class TypeProvider {
-	static format = TypeBoxFormat;
+	static format = Format;
 	static {
-		TypeBoxFormat.Set("bigint", (value) => TypeProvider.isValidBigInt(value));
+		Format.Set("bigint", (value) => TypeProvider.isValidBigInt(value));
 	}
 	static translateError(error, locale) {
 		if (!locale) return error.cause.message;
@@ -1899,6 +1893,192 @@ var TypeProvider = class TypeProvider {
 };
 const t = new TypeProvider();
 
+//#endregion
+//#region ../../src/core/helpers/jsonSchemaToTypeBox.ts
+/**
+* Converts a JSON Schema object to a TypeBox schema using Alepha's type system.
+*
+* This is useful when receiving JSON Schema from an API (e.g., configuration schemas)
+* and needing to use them with TypeBox-based form rendering or validation.
+*
+* **Supports:**
+* - Basic types: string, number, integer, boolean, null, object, array
+* - String formats: email, uuid, date-time, date, time, url/uri, binary, bigint, duration, color
+* - Enums (string enums)
+* - Nested objects with required/optional properties
+* - Arrays with item schemas
+* - Common validation options: minLength, maxLength, minimum, maximum, pattern
+*
+* **Not supported:**
+* - oneOf, anyOf, allOf, not (composition schemas)
+* - $ref (references)
+* - additionalProperties, patternProperties
+*
+* @param schema - JSON Schema object to convert
+* @returns TypeBox TSchema
+*
+* @example
+* ```ts
+* const jsonSchema = {
+*   type: "object",
+*   properties: {
+*     email: { type: "string", format: "email" },
+*     age: { type: "integer", minimum: 0 },
+*     active: { type: "boolean" },
+*   },
+*   required: ["email"]
+* };
+*
+* const typeBoxSchema = jsonSchemaToTypeBox(jsonSchema);
+* // Equivalent to:
+* // t.object({
+* //   email: t.email(),
+* //   age: t.optional(t.integer({ minimum: 0 })),
+* //   active: t.optional(t.boolean()),
+* // })
+* ```
+*/
+function jsonSchemaToTypeBox(schema) {
+	if (schema["~kind"]) return schema;
+	if (schema.const !== void 0) return t.const(schema.const);
+	if (schema.enum && Array.isArray(schema.enum)) {
+		if (schema.enum.every((v) => typeof v === "string")) return t.enum(schema.enum, filterUndefined({
+			title: schema.title,
+			description: schema.description,
+			default: schema.default
+		}));
+		return t.union(schema.enum.map((v) => t.const(v)));
+	}
+	switch (Array.isArray(schema.type) ? schema.type[0] : schema.type) {
+		case "string": return convertString(schema);
+		case "number": return convertNumber(schema);
+		case "integer": return convertInteger(schema);
+		case "boolean": return convertBoolean(schema);
+		case "null": return t.null();
+		case "object": return convertObject(schema);
+		case "array": return convertArray(schema);
+		default:
+			if (schema.properties) return convertObject(schema);
+			return t.any();
+	}
+}
+/**
+* Remove undefined values from an object.
+*/
+function filterUndefined(obj) {
+	return Object.fromEntries(Object.entries(obj).filter(([_, v]) => v !== void 0));
+}
+/**
+* Convert JSON Schema string type to TypeBox.
+*/
+function convertString(schema) {
+	const options = filterUndefined({
+		title: schema.title,
+		description: schema.description,
+		default: schema.default,
+		minLength: schema.minLength,
+		maxLength: schema.maxLength,
+		pattern: schema.pattern
+	});
+	switch (schema.format) {
+		case "email": return t.email(options);
+		case "uuid": return t.uuid(options);
+		case "date-time": return t.datetime(options);
+		case "date": return t.date(options);
+		case "time": return t.time(options);
+		case "url":
+		case "uri": return t.url(options);
+		case "binary": return t.binary(options);
+		case "bigint": return t.bigint(options);
+		case "duration": return t.duration(options);
+		case "color": return t.text({
+			...options,
+			format: "color"
+		});
+		case "e164": return t.e164(options);
+		case "bcp47": return t.bcp47(options);
+		default:
+			if (schema.format) return t.text({
+				...options,
+				format: schema.format
+			});
+			return t.text(options);
+	}
+}
+/**
+* Convert JSON Schema number type to TypeBox.
+*/
+function convertNumber(schema) {
+	return t.number(filterUndefined({
+		title: schema.title,
+		description: schema.description,
+		default: schema.default,
+		minimum: schema.minimum,
+		maximum: schema.maximum,
+		exclusiveMinimum: schema.exclusiveMinimum,
+		exclusiveMaximum: schema.exclusiveMaximum,
+		multipleOf: schema.multipleOf
+	}));
+}
+/**
+* Convert JSON Schema integer type to TypeBox.
+*/
+function convertInteger(schema) {
+	return t.integer(filterUndefined({
+		title: schema.title,
+		description: schema.description,
+		default: schema.default,
+		minimum: schema.minimum,
+		maximum: schema.maximum,
+		exclusiveMinimum: schema.exclusiveMinimum,
+		exclusiveMaximum: schema.exclusiveMaximum,
+		multipleOf: schema.multipleOf
+	}));
+}
+/**
+* Convert JSON Schema boolean type to TypeBox.
+*/
+function convertBoolean(schema) {
+	return t.boolean(filterUndefined({
+		title: schema.title,
+		description: schema.description,
+		default: schema.default
+	}));
+}
+/**
+* Convert JSON Schema object type to TypeBox.
+*/
+function convertObject(schema) {
+	if (!schema.properties) return t.json(filterUndefined({
+		title: schema.title,
+		description: schema.description
+	}));
+	const required = new Set(schema.required ?? []);
+	const properties = {};
+	for (const [key, propSchema] of Object.entries(schema.properties)) {
+		let converted = jsonSchemaToTypeBox(propSchema);
+		if (!required.has(key)) converted = t.optional(converted);
+		properties[key] = converted;
+	}
+	return t.object(properties, filterUndefined({
+		title: schema.title,
+		description: schema.description
+	}));
+}
+/**
+* Convert JSON Schema array type to TypeBox.
+*/
+function convertArray(schema) {
+	const itemSchema = schema.items ? jsonSchemaToTypeBox(schema.items) : t.any();
+	return t.array(itemSchema, filterUndefined({
+		title: schema.title,
+		description: schema.description,
+		minItems: schema.minItems,
+		maxItems: schema.maxItems,
+		uniqueItems: schema.uniqueItems
+	}));
+}
+
 //#endregion
 //#region ../../src/core/primitives/$env.ts
 /**
@@ -2114,5 +2294,5 @@ const run = (entry, opts) => {
 };
 
 //#endregion
-export { $atom, $context, $env, $hook, $inject, $module, $use, Alepha, AlephaError, AlsProvider, AppNotStartedError, Atom, CircularDependencyError, CodecManager, ContainerLockedError, EventManager, HookPrimitive, InjectPrimitive, JsonSchemaCodec, KIND, Module, OPTIONS, Primitive, SchemaCodec, StateManager, TooLateSubstitutionError, TypeBox, TypeBoxError, TypeBoxFormat, TypeBoxValue, TypeGuard, TypeProvider, createPagination, createPrimitive, isClass, isDate, isDateTime, isDuration, isEmail, isFileLike, isTime, isTypeFile, isURL, isUUID, pageMetadataSchema, pageQuerySchema, pageSchema, run, t };
+export { $atom, $context, $env, $hook, $inject, $module, $use, Alepha, AlephaError, AlsProvider, AppNotStartedError, Atom, CircularDependencyError, CodecManager, ContainerLockedError, EventManager, Format, HookPrimitive, InjectPrimitive, JsonSchemaCodec, KIND, Module, OPTIONS, Primitive, SchemaCodec, StateManager, TooLateSubstitutionError, Type, TypeBoxError, TypeGuard, TypeProvider, Value, createPagination, createPrimitive, isClass, isFileLike, isTypeFile, isUUID, jsonSchemaToTypeBox, pageMetadataSchema, pageQuerySchema, pageSchema, run, t };
 //# sourceMappingURL=index.browser.js.map