bleam 0.0.5 → 0.0.7

package/dist/index.js

@@ -1,5 +1,3 @@
-import "./native-runtime-BoqybBBf.js";
-import { t as crypto } from "./crypto-CCA_hvao.js";
-import { t as fs } from "./fs-BK7joD1g.js";
+import { n as createExpoConfig, r as defineConfig, t as appConfig } from "./config-CfWa3q-k.js";
 
-export { crypto, fs };
+export { appConfig, createExpoConfig, defineConfig };

package/dist/native-runtime-C85Nuc4F.js

@@ -0,0 +1,10 @@
+import NativeScript from "@nativescript/react-native";
+
+//#region src/native-runtime.ts
+NativeScript.init();
+function ensureNativeScript() {
+	return NativeScript;
+}
+
+//#endregion
+export { ensureNativeScript as t };

package/dist/{native-runtime-CdeT0JyQ.cjs → native-runtime-CsXnXkQn.cjs}

@@ -3,15 +3,8 @@ let __nativescript_react_native = require("@nativescript/react-native");
 __nativescript_react_native = require_chunk.__toESM(__nativescript_react_native);
 
 //#region src/native-runtime.ts
-let initialized = false;
-function globals() {
-	return globalThis;
-}
+__nativescript_react_native.default.init();
 function ensureNativeScript() {
-	if (!initialized) {
-		__nativescript_react_native.default.init();
-		initialized = true;
-	}
 	return __nativescript_react_native.default;
 }
 
@@ -21,10 +14,4 @@ Object.defineProperty(exports, 'ensureNativeScript', {
   get: function () {
     return ensureNativeScript;
   }
-});
-Object.defineProperty(exports, 'globals', {
-  enumerable: true,
-  get: function () {
-    return globals;
-  }
 });

package/dist/native-sqlite-xcGdamRD.js

@@ -0,0 +1,64 @@
+import "./native-runtime-C85Nuc4F.js";
+import { openOrCreate } from "@nativescript-community/sqlite";
+
+//#region src/native-sqlite.ts
+const databases = /* @__PURE__ */ new Map();
+function documentsDirectory() {
+	const path = NSSearchPathForDirectoriesInDomains(NSSearchPathDirectory.Document, NSSearchPathDomainMask.UserDomain, true).objectAtIndex(0);
+	if (!path) throw new Error("Could not resolve documents directory");
+	return String(path);
+}
+function ensureDirectory(path) {
+	const fileManager = NSFileManager.defaultManager;
+	if (fileManager.fileExistsAtPath(path)) return;
+	fileManager.createDirectoryAtPathWithIntermediateDirectoriesAttributesError(path, true, null, null);
+}
+function databasePath(name) {
+	const directory = `${documentsDirectory()}/bleam`;
+	ensureDirectory(directory);
+	return `${directory}/${name}`;
+}
+function toPluginParameters(parameters) {
+	return parameters;
+}
+function toSQLiteValue(value) {
+	if (typeof value === "string" || typeof value === "number" || value === null) return value;
+	throw new Error("SQLite blobs are not supported by Bleam state yet");
+}
+function toSQLiteRow(row) {
+	const output = {};
+	for (const [key, value] of Object.entries(row)) output[key] = toSQLiteValue(value);
+	return output;
+}
+var NativeSQLiteDatabase = class {
+	constructor(database) {
+		this.database = database;
+	}
+	execute(query, parameters) {
+		return this.database.execute(query, toPluginParameters(parameters));
+	}
+	async select(query, parameters) {
+		return (await this.database.select(query, toPluginParameters(parameters))).map(toSQLiteRow);
+	}
+	async get(query, parameters) {
+		const row = await this.database.get(query, toPluginParameters(parameters));
+		return row ? toSQLiteRow(row) : void 0;
+	}
+	transaction(action) {
+		return this.database.transaction(action);
+	}
+	close() {
+		this.database.close();
+	}
+};
+function openNativeSQLiteDatabase(name = "bleam.sqlite3") {
+	const path = databasePath(name);
+	const existing = databases.get(path);
+	if (existing) return new NativeSQLiteDatabase(existing);
+	const database = openOrCreate(path);
+	databases.set(path, database);
+	return new NativeSQLiteDatabase(database);
+}
+
+//#endregion
+export { NativeSQLiteDatabase, openNativeSQLiteDatabase };

package/dist/native-sqlite-yQLD5s9i.cjs

@@ -0,0 +1,66 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+require('./native-runtime-CsXnXkQn.cjs');
+let __nativescript_community_sqlite = require("@nativescript-community/sqlite");
+__nativescript_community_sqlite = require_chunk.__toESM(__nativescript_community_sqlite);
+
+//#region src/native-sqlite.ts
+const databases = /* @__PURE__ */ new Map();
+function documentsDirectory() {
+	const path = NSSearchPathForDirectoriesInDomains(NSSearchPathDirectory.Document, NSSearchPathDomainMask.UserDomain, true).objectAtIndex(0);
+	if (!path) throw new Error("Could not resolve documents directory");
+	return String(path);
+}
+function ensureDirectory(path) {
+	const fileManager = NSFileManager.defaultManager;
+	if (fileManager.fileExistsAtPath(path)) return;
+	fileManager.createDirectoryAtPathWithIntermediateDirectoriesAttributesError(path, true, null, null);
+}
+function databasePath(name) {
+	const directory = `${documentsDirectory()}/bleam`;
+	ensureDirectory(directory);
+	return `${directory}/${name}`;
+}
+function toPluginParameters(parameters) {
+	return parameters;
+}
+function toSQLiteValue(value) {
+	if (typeof value === "string" || typeof value === "number" || value === null) return value;
+	throw new Error("SQLite blobs are not supported by Bleam state yet");
+}
+function toSQLiteRow(row) {
+	const output = {};
+	for (const [key, value] of Object.entries(row)) output[key] = toSQLiteValue(value);
+	return output;
+}
+var NativeSQLiteDatabase = class {
+	constructor(database) {
+		this.database = database;
+	}
+	execute(query, parameters) {
+		return this.database.execute(query, toPluginParameters(parameters));
+	}
+	async select(query, parameters) {
+		return (await this.database.select(query, toPluginParameters(parameters))).map(toSQLiteRow);
+	}
+	async get(query, parameters) {
+		const row = await this.database.get(query, toPluginParameters(parameters));
+		return row ? toSQLiteRow(row) : void 0;
+	}
+	transaction(action) {
+		return this.database.transaction(action);
+	}
+	close() {
+		this.database.close();
+	}
+};
+function openNativeSQLiteDatabase(name = "bleam.sqlite3") {
+	const path = databasePath(name);
+	const existing = databases.get(path);
+	if (existing) return new NativeSQLiteDatabase(existing);
+	const database = (0, __nativescript_community_sqlite.openOrCreate)(path);
+	databases.set(path, database);
+	return new NativeSQLiteDatabase(database);
+}
+
+//#endregion
+exports.openNativeSQLiteDatabase = openNativeSQLiteDatabase;

package/dist/platform.cjs

@@ -0,0 +1,27 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+let expo = require("expo");
+expo = require_chunk.__toESM(expo);
+
+//#region src/platform.ts
+function getHelperStatus() {
+	return (0, expo.requireNativeModule)("Platform").helperStatus();
+}
+function downloadPlatformUpdate() {
+	return (0, expo.requireNativeModule)("Platform").downloadPlatformUpdate();
+}
+function updateAndRelaunch(releaseId) {
+	return (0, expo.requireNativeModule)("Platform").updateAndRelaunch(releaseId);
+}
+function getPermissionState(capability) {
+	return (0, expo.requireNativeModule)("Platform").permissionState(capability);
+}
+function getPermissionStates() {
+	return (0, expo.requireNativeModule)("Platform").permissionStates();
+}
+
+//#endregion
+exports.downloadPlatformUpdate = downloadPlatformUpdate;
+exports.getHelperStatus = getHelperStatus;
+exports.getPermissionState = getPermissionState;
+exports.getPermissionStates = getPermissionStates;
+exports.updateAndRelaunch = updateAndRelaunch;

package/dist/platform.d.cts

@@ -0,0 +1,39 @@
+//#region src/platform.d.ts
+type HelperCapability = 'platform-updates';
+type PermissionCapability = 'camera' | 'microphone' | 'photos' | 'contacts' | 'calendars' | 'reminders' | 'location';
+type PermissionStatus = 'not-determined' | 'denied' | 'restricted' | 'limited' | 'granted' | 'unsupported';
+interface PermissionState {
+  capability: PermissionCapability;
+  status: PermissionStatus;
+  granted: boolean;
+  canAskAgain: boolean;
+  expires: 'never';
+}
+interface HelperStatus {
+  healthy: boolean;
+  protocolVersion: 1;
+  helperVersion: string;
+  platformVersion: string;
+  capabilities: HelperCapability[];
+  updatesSupported: boolean;
+  installPath: string;
+  reason?: 'reinstall_required';
+}
+interface PlatformDownload {
+  releaseId: string;
+  appVersion: string;
+  buildNumber: string;
+  platformVersion: string;
+  artifactPath: string;
+  appPath: string;
+  sizeBytes: number;
+  sha256: string;
+  verified: true;
+}
+declare function getHelperStatus(): Promise<HelperStatus>;
+declare function downloadPlatformUpdate(): Promise<PlatformDownload>;
+declare function updateAndRelaunch(releaseId: string): Promise<void>;
+declare function getPermissionState(capability: PermissionCapability): Promise<PermissionState>;
+declare function getPermissionStates(): Promise<PermissionState[]>;
+//#endregion
+export { HelperCapability, HelperStatus, PermissionCapability, PermissionState, PermissionStatus, PlatformDownload, downloadPlatformUpdate, getHelperStatus, getPermissionState, getPermissionStates, updateAndRelaunch };

package/dist/platform.d.ts

@@ -0,0 +1,39 @@
+//#region src/platform.d.ts
+type HelperCapability = 'platform-updates';
+type PermissionCapability = 'camera' | 'microphone' | 'photos' | 'contacts' | 'calendars' | 'reminders' | 'location';
+type PermissionStatus = 'not-determined' | 'denied' | 'restricted' | 'limited' | 'granted' | 'unsupported';
+interface PermissionState {
+  capability: PermissionCapability;
+  status: PermissionStatus;
+  granted: boolean;
+  canAskAgain: boolean;
+  expires: 'never';
+}
+interface HelperStatus {
+  healthy: boolean;
+  protocolVersion: 1;
+  helperVersion: string;
+  platformVersion: string;
+  capabilities: HelperCapability[];
+  updatesSupported: boolean;
+  installPath: string;
+  reason?: 'reinstall_required';
+}
+interface PlatformDownload {
+  releaseId: string;
+  appVersion: string;
+  buildNumber: string;
+  platformVersion: string;
+  artifactPath: string;
+  appPath: string;
+  sizeBytes: number;
+  sha256: string;
+  verified: true;
+}
+declare function getHelperStatus(): Promise<HelperStatus>;
+declare function downloadPlatformUpdate(): Promise<PlatformDownload>;
+declare function updateAndRelaunch(releaseId: string): Promise<void>;
+declare function getPermissionState(capability: PermissionCapability): Promise<PermissionState>;
+declare function getPermissionStates(): Promise<PermissionState[]>;
+//#endregion
+export { HelperCapability, HelperStatus, PermissionCapability, PermissionState, PermissionStatus, PlatformDownload, downloadPlatformUpdate, getHelperStatus, getPermissionState, getPermissionStates, updateAndRelaunch };

package/dist/platform.js

@@ -0,0 +1,21 @@
+import { requireNativeModule } from "expo";
+
+//#region src/platform.ts
+function getHelperStatus() {
+	return requireNativeModule("Platform").helperStatus();
+}
+function downloadPlatformUpdate() {
+	return requireNativeModule("Platform").downloadPlatformUpdate();
+}
+function updateAndRelaunch(releaseId) {
+	return requireNativeModule("Platform").updateAndRelaunch(releaseId);
+}
+function getPermissionState(capability) {
+	return requireNativeModule("Platform").permissionState(capability);
+}
+function getPermissionStates() {
+	return requireNativeModule("Platform").permissionStates();
+}
+
+//#endregion
+export { downloadPlatformUpdate, getHelperStatus, getPermissionState, getPermissionStates, updateAndRelaunch };

package/dist/runtime.d.cts

@@ -1,14 +1,8 @@
 //#region src/runtime.d.ts
-interface RuntimeCapability {
-  name: string;
-  version?: string;
-}
 interface RuntimeSession {
   id: string;
   projectName: string;
   manifestUrl: string;
-  capabilities: RuntimeCapability[];
 }
 //#endregion
-export { RuntimeCapability, RuntimeSession };
-//# sourceMappingURL=runtime.d.cts.map
+export { RuntimeSession };

package/dist/runtime.d.ts

@@ -1,14 +1,8 @@
 //#region src/runtime.d.ts
-interface RuntimeCapability {
-  name: string;
-  version?: string;
-}
 interface RuntimeSession {
   id: string;
   projectName: string;
   manifestUrl: string;
-  capabilities: RuntimeCapability[];
 }
 //#endregion
-export { RuntimeCapability, RuntimeSession };
-//# sourceMappingURL=runtime.d.ts.map
+export { RuntimeSession };

package/dist/schema-Bo5Jvqus.js

@@ -0,0 +1,90 @@
+//#region src/schema.ts
+var SchemaError = class extends Error {
+	constructor(issues) {
+		super(issues.map((issue) => issue.message).join("\n"));
+		this.issues = issues;
+		this.name = "SchemaError";
+	}
+};
+function tokenMatches(token, value) {
+	return typeof value === token;
+}
+function issueFor(key, expected) {
+	return {
+		message: `Expected ${key} to be ${expected}`,
+		path: [key]
+	};
+}
+function parseShape(shape, value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return { issues: [{ message: "Expected object" }] };
+	const input = value;
+	const output = {};
+	const issues = [];
+	for (const [key, field] of Object.entries(shape)) {
+		const inputValue = input[key];
+		if (typeof field === "function") {
+			const defaultValue = field();
+			const expected = typeof defaultValue;
+			if (inputValue === void 0) {
+				output[key] = defaultValue;
+				continue;
+			}
+			if (tokenMatches(expected, inputValue)) {
+				output[key] = inputValue;
+				continue;
+			}
+			issues.push(issueFor(key, expected));
+			continue;
+		}
+		if (inputValue === void 0) continue;
+		if (tokenMatches(field, inputValue)) {
+			output[key] = inputValue;
+			continue;
+		}
+		issues.push(issueFor(key, field));
+	}
+	if (issues.length > 0) return { issues };
+	return { value: output };
+}
+function createSchema(validate, jsonSchema) {
+	return {
+		"~standard": {
+			version: 1,
+			vendor: "bleam",
+			validate
+		},
+		parse(value) {
+			const result = validate(value);
+			if (result.issues !== void 0) throw new SchemaError(result.issues);
+			return result.value;
+		},
+		safeParse: validate,
+		toJSONSchema: jsonSchema,
+		transform(transform) {
+			return createSchema((value) => {
+				const result = validate(value);
+				if (result.issues !== void 0) return result;
+				return { value: transform(result.value) };
+			}, jsonSchema);
+		}
+	};
+}
+function schema(shape) {
+	return createSchema((value) => parseShape(shape, value), () => {
+		const properties = {};
+		const required = [];
+		for (const [key, field] of Object.entries(shape)) {
+			if (typeof field === "function") properties[key] = { type: typeof field() };
+			else properties[key] = { type: field };
+			required.push(key);
+		}
+		return {
+			type: "object",
+			properties,
+			required
+		};
+	});
+}
+
+//#endregion
+export { schema as n, SchemaError as t };

package/dist/schema-DOOjfXvs.d.ts

@@ -0,0 +1,58 @@
+//#region src/schema.d.ts
+type FieldValue = string | number | boolean;
+type FieldToken = 'string' | 'number' | 'boolean';
+type FieldDefault<T extends FieldValue = FieldValue> = () => T;
+type FieldSchema = FieldToken | FieldDefault;
+type SchemaShape = Record<string, FieldSchema>;
+interface SchemaIssue {
+  message: string;
+  path?: ReadonlyArray<PropertyKey | {
+    key: PropertyKey;
+  }>;
+}
+type SchemaResult<Output> = {
+  value: Output;
+  issues?: undefined;
+} | {
+  issues: ReadonlyArray<SchemaIssue>;
+};
+interface StandardSchema<Input = unknown, Output = Input> {
+  readonly '~standard': {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly validate: (value: unknown) => SchemaResult<Output>;
+    readonly types?: {
+      readonly input: Input;
+      readonly output: Output;
+    };
+  };
+}
+type TokenValue<T extends FieldToken> = T extends 'string' ? string : T extends 'number' ? number : boolean;
+type DefaultValue<T> = T extends (() => infer Value) ? Value extends FieldValue ? Value : never : never;
+type TokenKeys<Shape extends SchemaShape> = { [Key in keyof Shape]: Shape[Key] extends FieldToken ? Key : never }[keyof Shape];
+type DefaultKeys<Shape extends SchemaShape> = { [Key in keyof Shape]: Shape[Key] extends FieldDefault ? Key : never }[keyof Shape];
+type FieldInput<Field extends FieldSchema> = Field extends FieldToken ? TokenValue<Field> : Field extends FieldDefault ? DefaultValue<Field> : never;
+type SchemaInput<Shape extends SchemaShape> = { [Key in keyof Shape]?: FieldInput<Shape[Key]> };
+type SchemaOutput<Shape extends SchemaShape> = { [Key in TokenKeys<Shape>]?: Shape[Key] extends FieldToken ? TokenValue<Shape[Key]> : never } & { [Key in DefaultKeys<Shape>]: Shape[Key] extends FieldDefault ? DefaultValue<Shape[Key]> : never };
+type InferInput<Value$1 extends StandardSchema> = NonNullable<Value$1['~standard']['types']>['input'];
+type InferOutput<Value$1 extends StandardSchema> = NonNullable<Value$1['~standard']['types']>['output'];
+declare class SchemaError extends Error {
+  readonly issues: ReadonlyArray<SchemaIssue>;
+  constructor(issues: ReadonlyArray<SchemaIssue>);
+}
+interface BleamSchema<Input, Output> extends StandardSchema<Input, Output> {
+  parse(value: unknown): Output;
+  safeParse(value: unknown): SchemaResult<Output>;
+  toJSONSchema(): SchemaJSONSchema;
+  transform<NextOutput>(transform: (value: Output) => NextOutput): BleamSchema<Input, NextOutput>;
+}
+type SchemaJSONSchema = {
+  type: 'object';
+  properties: Record<string, {
+    type: FieldToken;
+  }>;
+  required: string[];
+};
+declare function schema<Shape extends SchemaShape>(shape: Shape): BleamSchema<SchemaInput<Shape>, SchemaOutput<Shape>>;
+//#endregion
+export { FieldValue as a, SchemaError as c, SchemaJSONSchema as d, SchemaOutput as f, schema as g, StandardSchema as h, FieldToken as i, SchemaInput as l, SchemaShape as m, FieldDefault as n, InferInput as o, SchemaResult as p, FieldSchema as r, InferOutput as s, BleamSchema as t, SchemaIssue as u };

package/dist/schema-ENSMX_1t.d.cts

@@ -0,0 +1,58 @@
+//#region src/schema.d.ts
+type FieldValue = string | number | boolean;
+type FieldToken = 'string' | 'number' | 'boolean';
+type FieldDefault<T extends FieldValue = FieldValue> = () => T;
+type FieldSchema = FieldToken | FieldDefault;
+type SchemaShape = Record<string, FieldSchema>;
+interface SchemaIssue {
+  message: string;
+  path?: ReadonlyArray<PropertyKey | {
+    key: PropertyKey;
+  }>;
+}
+type SchemaResult<Output> = {
+  value: Output;
+  issues?: undefined;
+} | {
+  issues: ReadonlyArray<SchemaIssue>;
+};
+interface StandardSchema<Input = unknown, Output = Input> {
+  readonly '~standard': {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly validate: (value: unknown) => SchemaResult<Output>;
+    readonly types?: {
+      readonly input: Input;
+      readonly output: Output;
+    };
+  };
+}
+type TokenValue<T extends FieldToken> = T extends 'string' ? string : T extends 'number' ? number : boolean;
+type DefaultValue<T> = T extends (() => infer Value) ? Value extends FieldValue ? Value : never : never;
+type TokenKeys<Shape extends SchemaShape> = { [Key in keyof Shape]: Shape[Key] extends FieldToken ? Key : never }[keyof Shape];
+type DefaultKeys<Shape extends SchemaShape> = { [Key in keyof Shape]: Shape[Key] extends FieldDefault ? Key : never }[keyof Shape];
+type FieldInput<Field extends FieldSchema> = Field extends FieldToken ? TokenValue<Field> : Field extends FieldDefault ? DefaultValue<Field> : never;
+type SchemaInput<Shape extends SchemaShape> = { [Key in keyof Shape]?: FieldInput<Shape[Key]> };
+type SchemaOutput<Shape extends SchemaShape> = { [Key in TokenKeys<Shape>]?: Shape[Key] extends FieldToken ? TokenValue<Shape[Key]> : never } & { [Key in DefaultKeys<Shape>]: Shape[Key] extends FieldDefault ? DefaultValue<Shape[Key]> : never };
+type InferInput<Value$1 extends StandardSchema> = NonNullable<Value$1['~standard']['types']>['input'];
+type InferOutput<Value$1 extends StandardSchema> = NonNullable<Value$1['~standard']['types']>['output'];
+declare class SchemaError extends Error {
+  readonly issues: ReadonlyArray<SchemaIssue>;
+  constructor(issues: ReadonlyArray<SchemaIssue>);
+}
+interface BleamSchema<Input, Output> extends StandardSchema<Input, Output> {
+  parse(value: unknown): Output;
+  safeParse(value: unknown): SchemaResult<Output>;
+  toJSONSchema(): SchemaJSONSchema;
+  transform<NextOutput>(transform: (value: Output) => NextOutput): BleamSchema<Input, NextOutput>;
+}
+type SchemaJSONSchema = {
+  type: 'object';
+  properties: Record<string, {
+    type: FieldToken;
+  }>;
+  required: string[];
+};
+declare function schema<Shape extends SchemaShape>(shape: Shape): BleamSchema<SchemaInput<Shape>, SchemaOutput<Shape>>;
+//#endregion
+export { FieldValue as a, SchemaError as c, SchemaJSONSchema as d, SchemaOutput as f, schema as g, StandardSchema as h, FieldToken as i, SchemaInput as l, SchemaShape as m, FieldDefault as n, InferInput as o, SchemaResult as p, FieldSchema as r, InferOutput as s, BleamSchema as t, SchemaIssue as u };

package/dist/schema-rQ13mrpD.cjs

@@ -0,0 +1,102 @@
+
+//#region src/schema.ts
+var SchemaError = class extends Error {
+	constructor(issues) {
+		super(issues.map((issue) => issue.message).join("\n"));
+		this.issues = issues;
+		this.name = "SchemaError";
+	}
+};
+function tokenMatches(token, value) {
+	return typeof value === token;
+}
+function issueFor(key, expected) {
+	return {
+		message: `Expected ${key} to be ${expected}`,
+		path: [key]
+	};
+}
+function parseShape(shape, value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return { issues: [{ message: "Expected object" }] };
+	const input = value;
+	const output = {};
+	const issues = [];
+	for (const [key, field] of Object.entries(shape)) {
+		const inputValue = input[key];
+		if (typeof field === "function") {
+			const defaultValue = field();
+			const expected = typeof defaultValue;
+			if (inputValue === void 0) {
+				output[key] = defaultValue;
+				continue;
+			}
+			if (tokenMatches(expected, inputValue)) {
+				output[key] = inputValue;
+				continue;
+			}
+			issues.push(issueFor(key, expected));
+			continue;
+		}
+		if (inputValue === void 0) continue;
+		if (tokenMatches(field, inputValue)) {
+			output[key] = inputValue;
+			continue;
+		}
+		issues.push(issueFor(key, field));
+	}
+	if (issues.length > 0) return { issues };
+	return { value: output };
+}
+function createSchema(validate, jsonSchema) {
+	return {
+		"~standard": {
+			version: 1,
+			vendor: "bleam",
+			validate
+		},
+		parse(value) {
+			const result = validate(value);
+			if (result.issues !== void 0) throw new SchemaError(result.issues);
+			return result.value;
+		},
+		safeParse: validate,
+		toJSONSchema: jsonSchema,
+		transform(transform) {
+			return createSchema((value) => {
+				const result = validate(value);
+				if (result.issues !== void 0) return result;
+				return { value: transform(result.value) };
+			}, jsonSchema);
+		}
+	};
+}
+function schema(shape) {
+	return createSchema((value) => parseShape(shape, value), () => {
+		const properties = {};
+		const required = [];
+		for (const [key, field] of Object.entries(shape)) {
+			if (typeof field === "function") properties[key] = { type: typeof field() };
+			else properties[key] = { type: field };
+			required.push(key);
+		}
+		return {
+			type: "object",
+			properties,
+			required
+		};
+	});
+}
+
+//#endregion
+Object.defineProperty(exports, 'SchemaError', {
+  enumerable: true,
+  get: function () {
+    return SchemaError;
+  }
+});
+Object.defineProperty(exports, 'schema', {
+  enumerable: true,
+  get: function () {
+    return schema;
+  }
+});

package/dist/schema.cjs

@@ -0,0 +1,4 @@
+const require_schema = require('./schema-rQ13mrpD.cjs');
+
+exports.SchemaError = require_schema.SchemaError;
+exports.schema = require_schema.schema;

package/dist/schema.d.cts

@@ -0,0 +1,2 @@
+import { a as FieldValue, c as SchemaError, d as SchemaJSONSchema, f as SchemaOutput, g as schema, h as StandardSchema, i as FieldToken, l as SchemaInput, m as SchemaShape, n as FieldDefault, o as InferInput, p as SchemaResult, r as FieldSchema, s as InferOutput, t as BleamSchema, u as SchemaIssue } from "./schema-ENSMX_1t.cjs";
+export { BleamSchema, FieldDefault, FieldSchema, FieldToken, FieldValue, InferInput, InferOutput, SchemaError, SchemaInput, SchemaIssue, SchemaJSONSchema, SchemaOutput, SchemaResult, SchemaShape, StandardSchema, schema };

package/dist/schema.d.ts

@@ -0,0 +1,2 @@
+import { a as FieldValue, c as SchemaError, d as SchemaJSONSchema, f as SchemaOutput, g as schema, h as StandardSchema, i as FieldToken, l as SchemaInput, m as SchemaShape, n as FieldDefault, o as InferInput, p as SchemaResult, r as FieldSchema, s as InferOutput, t as BleamSchema, u as SchemaIssue } from "./schema-DOOjfXvs.js";
+export { BleamSchema, FieldDefault, FieldSchema, FieldToken, FieldValue, InferInput, InferOutput, SchemaError, SchemaInput, SchemaIssue, SchemaJSONSchema, SchemaOutput, SchemaResult, SchemaShape, StandardSchema, schema };

package/dist/schema.js

@@ -0,0 +1,3 @@
+import { n as schema, t as SchemaError } from "./schema-Bo5Jvqus.js";
+
+export { SchemaError, schema };