tinybase 7.1.0-beta.0 → 7.1.0-beta.2

package/@types/persisters/index.d.ts

@@ -232,8 +232,8 @@ export type PersisterListener<Persist extends Persists = Persists.StoreOnly> = (
  * @category Listener
  * @since v5.3.0
  */
-export type StatusListener<Persist extends Persists = Persists.StoreOnly> = (
-  persister: Persister<Persist>,
+export type StatusListener<Persister extends AnyPersister = AnyPersister> = (
+  persister: Persister,
   status: Status,
 ) => void;
 
@@ -1465,7 +1465,7 @@ export interface Persister<Persist extends Persists = Persists.StoreOnly> {
    * @category Listener
    * @since v5.3.0
    */
-  addStatusListener(listener: StatusListener<Persist>): Id;
+  addStatusListener(listener: StatusListener<this>): Id;
 
   /**
    * The delListener method removes a listener that was previously added to the

package/@types/persisters/with-schemas/index.d.ts

@@ -283,8 +283,8 @@ export type PersisterListener<
  * This has schema-based typing. The following is a simplified representation:
  *
  * ```ts override
- * export type StatusListener<Persist extends Persists = Persists.StoreOnly> = (
- *   persister: Persister<Persist>,
+ * export type StatusListener<Persister extends AnyPersister = AnyPersister> = (
+ *   persister: Persister,
  *   status: Status,
  * ) => void;
  * ```
@@ -301,8 +301,8 @@ export type PersisterListener<
  */
 export type StatusListener<
   Schemas extends OptionalSchemas,
-  Persist extends Persists = Persists.StoreOnly,
-> = (persister: Persister<Schemas, Persist>, status: Status) => void;
+  Persister extends AnyPersister<Schemas> = AnyPersister<Schemas>,
+> = (persister: Persister, status: Status) => void;
 
 /**
  * The PersisterStats type describes the number of times a Persister object has
@@ -1536,7 +1536,7 @@ export interface Persister<
    * This has schema-based typing. The following is a simplified representation:
    *
    * ```ts override
-   * addStatusListener(listener: StatusListener<Persist>): Id;
+   * addStatusListener(listener: StatusListener<this>): Id;
    * ```
    *
    * The provided listener is a StatusListener function, and will be called with
@@ -1573,7 +1573,7 @@ export interface Persister<
    * @category Listener
    * @since v5.3.0
    */
-  addStatusListener(listener: StatusListener<Schemas, Persist>): Id;
+  addStatusListener(listener: StatusListener<Schemas, this>): Id;
 
   /**
    * The delListener method removes a listener that was previously added to the

package/@types/schematizers/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The schematizers module provides utilities for converting schemas from
+ * popular validation libraries into TinyBase's schema format.
+ *
+ * Schematizers perform "best-effort" conversion, extracting basic type
+ * information (string, number, boolean) and default values while discarding
+ * complex validation rules that TinyBase doesn't support.
+ * @packageDocumentation
+ * @module schematizers
+ * @since v7.1.0
+ */
+import type {TablesSchema, ValuesSchema} from '../store/index.d.ts';
+
+/**
+ * The Schematizer interface represents a schema converter that can transform
+ * external validation library schemas into TinyBase TablesSchema and
+ * ValuesSchema formats.
+ * @category Schematizer
+ * @since v7.1.0
+ */
+export interface Schematizer {
+  /**
+ * The toTablesSchema method converts a mapping of external schemas into a
+ * TinyBase TablesSchema.
+ * @param schemas - A mapping of table IDs to external schema objects.
+ * @returns A TinyBase TablesSchema.
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toTablesSchema(schemas: any): TablesSchema;
+
+  /**
+ * The toValuesSchema method converts a mapping of external schemas into a
+ * TinyBase ValuesSchema.
+ * @param schemas - A mapping of value IDs to external schema objects.
+ * @returns A TinyBase ValuesSchema.
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toValuesSchema(schemas: any): ValuesSchema;
+}

package/@types/schematizers/schematizer-typebox/index.d.ts

@@ -0,0 +1,116 @@
+/**
+ * The schematizer-typebox module provides conversion utilities for TypeBox
+ * schemas.
+ * @packageDocumentation
+ * @module schematizer-typebox
+ * @since v7.1.0
+ */
+import type {TablesSchema, ValuesSchema} from '../../store/index.d.ts';
+import type {Schematizer} from '../index.d.ts';
+
+/**
+ * The TypeBoxSchematizer interface represents a schematizer specifically for
+ * converting TypeBox schemas into TinyBase schemas.
+ * @category Schematizer
+ * @since v7.1.0
+ */
+export interface TypeBoxSchematizer extends Schematizer {
+  /**
+ * The toTablesSchema method converts a mapping of TypeBox object schemas into a
+ * TinyBase TablesSchema.
+ *
+ * This method extracts basic type information (string, number, boolean),
+ * default values, and nullable flags from TypeBox schemas. Complex validation
+ * rules like min/max, patterns, formats, and custom validators are ignored.
+ * @param schemas - A mapping of table IDs to TypeBox object schemas.
+ * @returns A TinyBase TablesSchema.
+ * @example
+ * This example converts TypeBox schemas to TinyBase format.
+ *
+ * ```js
+ * import {Type} from '@sinclair/typebox';
+ * import {createStore} from 'tinybase';
+ * import {createTypeBoxSchematizer} from 'tinybase/schematizers/schematizer-typebox';
+ *
+ * const schematizer = createTypeBoxSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: Type.Object({
+ *     species: Type.String(),
+ *     age: Type.Number(),
+ *     sold: Type.Boolean({default: false}),
+ *   }),
+ * });
+ *
+ * const store = createStore().setTablesSchema(tablesSchema);
+ * store.setRow('pets', 'fido', {species: 'dog', age: 3});
+ * console.log(store.getRow('pets', 'fido'));
+ * // -> {species: 'dog', age: 3, sold: false}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toTablesSchema(schemas: {[tableId: string]: any}): TablesSchema;
+
+  /**
+ * The toValuesSchema method converts a mapping of TypeBox schemas into a
+ * TinyBase ValuesSchema.
+ *
+ * This method extracts basic type information (string, number, boolean),
+ * default values, and nullable flags from TypeBox schemas.
+ * @param schemas - A mapping of value IDs to TypeBox schemas.
+ * @returns A TinyBase ValuesSchema.
+ * @example
+ * This example converts TypeBox schemas to TinyBase ValuesSchema format.
+ *
+ * ```js
+ * import {Type} from '@sinclair/typebox';
+ * import {createStore} from 'tinybase';
+ * import {createTypeBoxSchematizer} from 'tinybase/schematizers/schematizer-typebox';
+ *
+ * const schematizer = createTypeBoxSchematizer();
+ *
+ * const valuesSchema = schematizer.toValuesSchema({
+ *   theme: Type.String({default: 'light'}),
+ *   count: Type.Number(),
+ *   isOpen: Type.Boolean(),
+ * });
+ *
+ * const store = createStore().setValuesSchema(valuesSchema);
+ * store.setValue('count', 42);
+ * console.log(store.getValues());
+ * // -> {theme: 'light', count: 42}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toValuesSchema(schemas: {[valueId: string]: any}): ValuesSchema;
+}
+
+/**
+ * The createTypeBoxSchematizer function creates a TypeBoxSchematizer object
+ * that can convert TypeBox schemas into TinyBase schemas.
+ *
+ * The schematizer is stateless and can be reused for multiple conversions.
+ * @returns A new TypeBoxSchematizer instance.
+ * @example
+ * This example creates a TypeBox schematizer and uses it to convert schemas.
+ *
+ * ```js
+ * import {Type} from '@sinclair/typebox';
+ * import {createTypeBoxSchematizer} from 'tinybase/schematizers/schematizer-typebox';
+ *
+ * const schematizer = createTypeBoxSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: Type.Object({
+ *     species: Type.String(),
+ *   }),
+ * });
+ * console.log(tablesSchema);
+ * // -> {pets: {species: {type: 'string'}}}
+ * ```
+ * @category Creation
+ * @since v7.1.0
+ */
+export function createTypeBoxSchematizer(): TypeBoxSchematizer;

package/@types/schematizers/schematizer-typebox/with-schemas/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The schematizer-typebox module provides conversion utilities for TypeBox
+ * schemas.
+ * @packageDocumentation
+ * @module schematizer-typebox
+ * @since v7.1.0
+ */
+export type {TypeBoxSchematizer, createTypeBoxSchematizer} from '../index.d.ts';

package/@types/schematizers/schematizer-zod/index.d.ts

@@ -0,0 +1,113 @@
+/**
+ * The schematizer-zod module provides conversion utilities for Zod schemas.
+ * @packageDocumentation
+ * @module schematizer-zod
+ * @since v7.1.0
+ */
+import type {TablesSchema, ValuesSchema} from '../../store/index.d.ts';
+import type {Schematizer} from '../index.d.ts';
+
+/**
+ * The ZodSchematizer interface represents a schematizer specifically for
+ * converting Zod schemas into TinyBase schemas.
+ * @category Schematizer
+ * @since v7.1.0
+ */
+export interface ZodSchematizer extends Schematizer {
+  /**
+ * The toTablesSchema method converts a mapping of Zod object schemas into a
+ * TinyBase TablesSchema.
+ *
+ * This method extracts basic type information (string, number, boolean),
+ * default values, and nullable flags from Zod schemas. Complex validation
+ * rules like min/max, regex patterns, refinements, and transforms are ignored.
+ * @param schemas - A mapping of table IDs to Zod object schemas.
+ * @returns A TinyBase TablesSchema.
+ * @example
+ * This example converts Zod schemas to TinyBase format.
+ *
+ * ```js
+ * import {createStore} from 'tinybase';
+ * import {createZodSchematizer} from 'tinybase/schematizers/schematizer-zod';
+ * import {z} from 'zod';
+ *
+ * const schematizer = createZodSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: z.object({
+ *     species: z.string(),
+ *     age: z.number(),
+ *     sold: z.boolean().default(false),
+ *   }),
+ * });
+ *
+ * const store = createStore().setTablesSchema(tablesSchema);
+ * store.setRow('pets', 'fido', {species: 'dog', age: 3});
+ * console.log(store.getRow('pets', 'fido'));
+ * // -> {species: 'dog', age: 3, sold: false}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toTablesSchema(schemas: {[tableId: string]: any}): TablesSchema;
+
+  /**
+ * The toValuesSchema method converts a mapping of Zod schemas into a TinyBase
+ * ValuesSchema.
+ *
+ * This method extracts basic type information and default values from Zod
+ * schemas.
+ * @param schemas - A mapping of value IDs to Zod schemas.
+ * @returns A TinyBase ValuesSchema.
+ * @example
+ * This example converts Zod value schemas.
+ *
+ * ```js
+ * import {createStore} from 'tinybase';
+ * import {createZodSchematizer} from 'tinybase/schematizers/schematizer-zod';
+ * import {z} from 'zod';
+ *
+ * const schematizer = createZodSchematizer();
+ *
+ * const valuesSchema = schematizer.toValuesSchema({
+ *   theme: z.string().default('light'),
+ *   count: z.number(),
+ * });
+ *
+ * const store = createStore().setValuesSchema(valuesSchema);
+ * console.log(store.getValues());
+ * // -> {theme: 'light'}
+ * ```
+ * @category Conversion
+ * @since v7.1.0
+ */
+  toValuesSchema(schemas: {[valueId: string]: any}): ValuesSchema;
+}
+
+/**
+ * The createZodSchematizer function creates a ZodSchematizer object that can
+ * convert Zod schemas into TinyBase schemas.
+ *
+ * The schematizer is stateless and can be reused for multiple conversions.
+ * @returns A new ZodSchematizer instance.
+ * @example
+ * This example creates a Zod schematizer and uses it to convert schemas.
+ *
+ * ```js
+ * import {createZodSchematizer} from 'tinybase/schematizers/schematizer-zod';
+ * import {z} from 'zod';
+ *
+ * const schematizer = createZodSchematizer();
+ *
+ * const tablesSchema = schematizer.toTablesSchema({
+ *   pets: z.object({
+ *     species: z.string(),
+ *   }),
+ * });
+ * console.log(tablesSchema);
+ * // -> {pets: {species: {type: 'string'}}}
+ * ```
+ * @category Creation
+ * @since v7.1.0
+ */
+export function createZodSchematizer(): ZodSchematizer;

package/@types/schematizers/schematizer-zod/with-schemas/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The schematizer-zod module provides conversion utilities for Zod schemas.
+ * @packageDocumentation
+ * @module schematizer-zod
+ * @since v7.1.0
+ */
+export type {ZodSchematizer, createZodSchematizer} from '../index.d.ts';

package/@types/schematizers/with-schemas/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The schematizers module provides utilities for converting schemas from
+ * popular validation libraries into TinyBase's schema format.
+ *
+ * Schematizers perform "best-effort" conversion, extracting basic type
+ * information (string, number, boolean) and default values while discarding
+ * complex validation rules that TinyBase doesn't support.
+ * @packageDocumentation
+ * @module schematizers
+ * @since v7.1.0
+ */
+export type {Schematizer} from '../index.d.ts';

package/@types/ui-react/index.d.ts

@@ -12475,7 +12475,7 @@ export function usePersisterStatus(
  * @since v5.3.0
  */
 export function usePersisterStatusListener(
-  listener: StatusListener<Persists.StoreOrMergeableStore>,
+  listener: StatusListener,
   listenerDeps?: React.DependencyList,
   persisterOrPersisterId?: PersisterOrPersisterId,
 ): void;
@@ -13053,7 +13053,7 @@ export function useSynchronizerStatus(
  * @since v5.3.0
  */
 export function useSynchronizerStatusListener(
-  listener: StatusListener<Persists.MergeableStoreOnly>,
+  listener: StatusListener,
   listenerDeps?: React.DependencyList,
   synchronizerOrSynchronizerId?: SynchronizerOrSynchronizerId,
 ): void;

package/@types/ui-react/with-schemas/index.d.ts

@@ -13487,7 +13487,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  *
  * ```ts override
  * usePersisterStatusListener(
- *   listener: StatusListener<Persists.StoreOrMergeableStore>,
+ *   listener: StatusListener,
  *   listenerDeps?: React.DependencyList,
  *   persisterOrPersisterId?: PersisterOrPersisterId,
  * ): void;
@@ -13553,7 +13553,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @since v5.3.0
  */
   usePersisterStatusListener: (
-    listener: StatusListener<Schemas, Persists.StoreOrMergeableStore>,
+    listener: StatusListener<Schemas>,
     listenerDeps?: React.DependencyList,
     persisterOrPersisterId?: PersisterOrPersisterId<Schemas>,
   ) => void;
@@ -14039,7 +14039,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  *
  * ```ts override
  * useSynchronizerStatusListener(
- *   listener: StatusListener<Persists.MergeableStoreOnly>,
+ *   listener: StatusListener,
  *   listenerDeps?: React.DependencyList,
  *   synchronizerOrSynchronizerId?: SynchronizerOrSynchronizerId,
  * ): void;
@@ -14105,7 +14105,7 @@ export type WithSchemas<Schemas extends OptionalSchemas> = {
  * @since v5.3.0
  */
   useSynchronizerStatusListener: (
-    listener: StatusListener<Schemas, Persists.StoreOrMergeableStore>,
+    listener: StatusListener<Schemas>,
     listenerDeps?: React.DependencyList,
     synchronizerOrSynchronizerId?: SynchronizerOrSynchronizerId<Schemas>,
   ) => void;

package/agents.md

@@ -341,3 +341,147 @@ npx vitest run ./test/unit/documentation.test.ts --retry=0
 2. **Guide Content**: Edit markdown files in `/site/guides/`
 3. **Release Notes**: Edit `/site/guides/16_releases.md` (not `/releases.md`)
 4. **Always run documentation tests** after changes to verify examples work
+
+## Creating New Schematizers
+
+Schematizers convert external schema validation libraries (like Zod) to TinyBase
+schemas. Follow this pattern:
+
+### Module Structure
+
+```
+src/@types/schematizers/schematizer-{library}/
+  index.d.ts           # Type definitions
+  docs.js              # Documentation
+  with-schemas/
+    index.d.ts         # Re-exports for schema-aware variants
+src/schematizers/schematizer-{library}/
+  index.ts             # Implementation
+```
+
+### Factory Pattern
+
+```typescript
+export const createZodSchematizer: typeof createZodSchematizerDecl = () => {
+  const toTablesSchema = (schemas: {[tableId: string]: any}): TablesSchema => {
+    // Best-effort conversion logic
+  };
+
+  const toValuesSchema = (schemas: {[valueId: string]: any}): ValuesSchema => {
+    // Best-effort conversion logic
+  };
+
+  return objFreeze({
+    toTablesSchema,
+    toValuesSchema,
+  });
+};
+```
+
+### Conversion Strategy
+
+- Extract basic types only: `string`, `number`, `boolean`
+- Handle defaults via schema introspection
+- Support nullable and optional modifiers
+- **Ignore** complex types (arrays, objects, etc.) - they won't appear in output
+- Use recursive unwrapping for wrapper types (e.g., `ZodOptional`, `ZodNullable`,
+  `ZodDefault`)
+
+### Implementation Idioms
+
+- Use `objForEach` for iteration, not `for...in` loops
+- Use `ifNotUndefined` for conditional logic
+- Use `objIsEmpty` to filter out empty table schemas
+- Extract string constants to module-level (e.g., `TYPE`, `DEFAULT`,
+  `ALLOW_NULL`)
+- Freeze the returned schematizer object with `objFreeze`
+
+### Example Conversion Logic
+
+```typescript
+const unwrap = (
+  schema: any,
+  defaultValue?: any,
+  allowNull?: boolean,
+): [any, any, boolean] => {
+  const typeName = schema._def?.typeName;
+  return typeName === ZOD_OPTIONAL
+    ? unwrap(schema._def.innerType, defaultValue, allowNull)
+    : typeName === ZOD_NULLABLE
+      ? unwrap(schema._def.innerType, defaultValue, true)
+      : typeName === ZOD_DEFAULT
+        ? unwrap(schema._def.innerType, schema._def.defaultValue(), allowNull)
+        : [schema, defaultValue, allowNull ?? false];
+};
+```
+
+### Build Configuration
+
+- Add module to `ALL_MODULES` array in `gulpfile.mjs`
+- Add peer dependency to `package.json` (marked as optional)
+- Add as dev dependency for testing
+
+### Testing
+
+- Create comprehensive test suite in
+  `test/unit/schematizers/schematizer-{library}.test.ts`
+- Test basic type conversion, defaults, nullable, optional
+- Test unsupported types are filtered out
+- Test integration with actual TinyBase stores
+- Inline schemas directly in test calls (no intermediate variables unless needed
+  multiple times)
+
+### Documentation Testing
+
+Add library import to `test/unit/documentation.test.ts`:
+
+```typescript
+import * as z from 'zod';
+import * as TinyBaseSchematizersZod from 'tinybase/schematizers/schematizer-zod';
+
+(globalThis as any).modules = {
+  ...
+  'tinybase/schematizers/schematizer-zod': TinyBaseSchematizersZod,
+  zod: z,
+};
+```
+
+## Guide Writing Best Practices
+
+### Examples Run Sequentially
+
+All code examples in a guide file are concatenated and executed as a test:
+
+- Use unique variable names (`store`, `store2`, `store3`) to avoid redeclaration
+- First example includes all imports, later examples reuse them
+- Clean up between examples if needed (`store.delTables()`)
+
+### Inline Simple Values
+
+- Prefer inline schemas/data in method calls over intermediate variables
+- Only extract to variables when used multiple times
+- Keeps examples concise and focused
+
+### Guide Chains
+
+- Each guide's summary should link to the next guide in sequence
+- Pattern: "For that we proceed to the [Next Topic] guide."
+- Creates a natural learning path
+
+## Release Notes Updates
+
+When adding a new feature:
+
+1. **Update `/site/guides/16_releases.md`** (NOT `/releases.md`):
+   - Add new version section at the top
+   - Include working code example that will be tested
+   - Link to relevant guide if applicable
+   - Use past releases as template for structure
+
+2. **Update `/site/home/index.md`**:
+   - Update the "NEW!" link to point to new version:
+     `<a href='/guides/releases/#v7-1'>`
+   - Update the tagline:
+     `<span id="one-with">"The one with Schematizers!"</span>`
+
+3. **Generated files update automatically** during build process

package/index.js

@@ -7,6 +7,7 @@ const FUNCTION = getTypeOf(getTypeOf);
 const TYPE = 'type';
 const DEFAULT = 'default';
 const ALLOW_NULL = 'allowNull';
+const NULL = 'null';
 const SUM = 'sum';
 const AVG = 'avg';
 const MIN = 'min';
@@ -94,7 +95,7 @@ const arrayShift = (array) => array.shift();
 
 const getCellOrValueType = (cellOrValue) => {
   if (isNull(cellOrValue)) {
-    return 'null';
+    return NULL;
   }
   const type = getTypeOf(cellOrValue);
   return isTypeStringOrBoolean(type) ||

package/mergeable-store/index.js

@@ -7,6 +7,7 @@ const FUNCTION = getTypeOf(getTypeOf);
 const TYPE = 'type';
 const DEFAULT = 'default';
 const ALLOW_NULL = 'allowNull';
+const NULL = 'null';
 const LISTENER = 'Listener';
 const SET = 'set';
 const ADD = 'add';
@@ -63,7 +64,7 @@ const tryCatch = async (action, then1, then2) => {
 
 const getCellOrValueType = (cellOrValue) => {
   if (isNull(cellOrValue)) {
-    return 'null';
+    return NULL;
   }
   const type = getTypeOf(cellOrValue);
   return isTypeStringOrBoolean(type) ||

package/mergeable-store/with-schemas/index.js

@@ -7,6 +7,7 @@ const FUNCTION = getTypeOf(getTypeOf);
 const TYPE = 'type';
 const DEFAULT = 'default';
 const ALLOW_NULL = 'allowNull';
+const NULL = 'null';
 const LISTENER = 'Listener';
 const SET = 'set';
 const ADD = 'add';
@@ -63,7 +64,7 @@ const tryCatch = async (action, then1, then2) => {
 
 const getCellOrValueType = (cellOrValue) => {
   if (isNull(cellOrValue)) {
-    return 'null';
+    return NULL;
   }
   const type = getTypeOf(cellOrValue);
   return isTypeStringOrBoolean(type) ||

package/min/schematizers/index.js

@@ -0,0 +1 @@
+

package/min/schematizers/schematizer-typebox/index.js

@@ -0,0 +1 @@
+const t=t=>typeof t,e=t(""),r=t(!0),n=t(0),o="type",s="default",c="null",l=t=>(e,r,n)=>t(e)?n?.():r(e),u=t=>null==t,f=l(u),p=l(t=>void 0===t),a=Object,y=t=>a.getPrototypeOf(t),i=a.entries,h=a.keys,m=a.freeze,d=(t=[])=>a.fromEntries(t),O=(t,e)=>((t,e)=>t.forEach(e))(i(t),([t,r])=>e(r,t)),b="anyOf",g=(t,e,r)=>{if(t?.[b]){const r=t[b],n=r.some(t=>t?.type===c),o=r.find(t=>t?.type!==c);if(n&&o)return g(o,e??t?.[s],!0)}return[t,e??t?.[s],r??!1]},v=()=>{const t=t=>{const[c,l,u]=g(t),f=c?.type;if(f!==e&&f!==n&&f!==r)return;const a={[o]:f};return p(l,t=>{a[s]=t}),u&&(a.allowNull=!0),a};return m({toTablesSchema:e=>{const r=d();return O(e,(e,n)=>{const o=d();var s;p(e?.properties,e=>O(e,(e,r)=>p(t(e),t=>{o[r]=t}))),(t=>!u(t)&&f(y(t),t=>t==a.prototype||u(y(t)),()=>!0))(s=o)&&0==(t=>h(t).length)(s)||(r[n]=o)}),r},toValuesSchema:e=>{const r=d();return O(e,(e,n)=>p(t(e),t=>{r[n]=t})),r}})};export{v as createTypeBoxSchematizer};

package/min/schematizers/schematizer-typebox/with-schemas/index.js

@@ -0,0 +1 @@
+const t=t=>typeof t,e=t(""),r=t(!0),n=t(0),o="type",s="default",c="null",l=t=>(e,r,n)=>t(e)?n?.():r(e),u=t=>null==t,f=l(u),p=l(t=>void 0===t),a=Object,y=t=>a.getPrototypeOf(t),i=a.entries,h=a.keys,m=a.freeze,d=(t=[])=>a.fromEntries(t),O=(t,e)=>((t,e)=>t.forEach(e))(i(t),([t,r])=>e(r,t)),b="anyOf",g=(t,e,r)=>{if(t?.[b]){const r=t[b],n=r.some(t=>t?.type===c),o=r.find(t=>t?.type!==c);if(n&&o)return g(o,e??t?.[s],!0)}return[t,e??t?.[s],r??!1]},v=()=>{const t=t=>{const[c,l,u]=g(t),f=c?.type;if(f!==e&&f!==n&&f!==r)return;const a={[o]:f};return p(l,t=>{a[s]=t}),u&&(a.allowNull=!0),a};return m({toTablesSchema:e=>{const r=d();return O(e,(e,n)=>{const o=d();var s;p(e?.properties,e=>O(e,(e,r)=>p(t(e),t=>{o[r]=t}))),(t=>!u(t)&&f(y(t),t=>t==a.prototype||u(y(t)),()=>!0))(s=o)&&0==(t=>h(t).length)(s)||(r[n]=o)}),r},toValuesSchema:e=>{const r=d();return O(e,(e,n)=>p(t(e),t=>{r[n]=t})),r}})};export{v as createTypeBoxSchematizer};

package/min/schematizers/schematizer-zod/index.js

@@ -0,0 +1 @@
+const e=e=>typeof e,t=e(""),n=e(!0),r=e(0),o="type",l="default",f=e=>(t,n,r)=>e(t)?r?.():n(t),s=e=>null==e,a=f(s),p=f(e=>void 0===e),u=Object,c=e=>u.getPrototypeOf(e),y=u.entries,d=u.keys,i=u.freeze,h=(e=[])=>u.fromEntries(e),T=(e,t)=>((e,t)=>e.forEach(t))(y(e),([e,n])=>t(n,e)),b=(e,t,n)=>{const r=e?.def?.type;return"optional"===r?b(e.def.innerType,t,n):"nullable"===r?b(e.def.innerType,t,!0):r===l?b(e.def.innerType,e.def.defaultValue,n):[e,t,n??!1]},m=()=>{const e=e=>{const[f,s,a]=b(e),u=f?.type;if(u!==t&&u!==r&&u!==n)return;const c={[o]:u};return p(s,e=>{c[l]=e}),a&&(c.allowNull=!0),c};return i({toTablesSchema:t=>{const n=h();return T(t,(t,r)=>{const o=h();var l;p(t?.def?.shape,t=>T(t,(t,n)=>p(e(t),e=>{o[n]=e}))),(e=>!s(e)&&a(c(e),e=>e==u.prototype||s(c(e)),()=>!0))(l=o)&&0==(e=>d(e).length)(l)||(n[r]=o)}),n},toValuesSchema:t=>{const n=h();return T(t,(t,r)=>p(e(t),e=>{n[r]=e})),n}})};export{m as createZodSchematizer};

package/min/schematizers/schematizer-zod/with-schemas/index.js

@@ -0,0 +1 @@
+const e=e=>typeof e,t=e(""),n=e(!0),r=e(0),o="type",l="default",f=e=>(t,n,r)=>e(t)?r?.():n(t),s=e=>null==e,a=f(s),p=f(e=>void 0===e),u=Object,c=e=>u.getPrototypeOf(e),y=u.entries,d=u.keys,i=u.freeze,h=(e=[])=>u.fromEntries(e),T=(e,t)=>((e,t)=>e.forEach(t))(y(e),([e,n])=>t(n,e)),b=(e,t,n)=>{const r=e?.def?.type;return"optional"===r?b(e.def.innerType,t,n):"nullable"===r?b(e.def.innerType,t,!0):r===l?b(e.def.innerType,e.def.defaultValue,n):[e,t,n??!1]},m=()=>{const e=e=>{const[f,s,a]=b(e),u=f?.type;if(u!==t&&u!==r&&u!==n)return;const c={[o]:u};return p(s,e=>{c[l]=e}),a&&(c.allowNull=!0),c};return i({toTablesSchema:t=>{const n=h();return T(t,(t,r)=>{const o=h();var l;p(t?.def?.shape,t=>T(t,(t,n)=>p(e(t),e=>{o[n]=e}))),(e=>!s(e)&&a(c(e),e=>e==u.prototype||s(c(e)),()=>!0))(l=o)&&0==(e=>d(e).length)(l)||(n[r]=o)}),n},toValuesSchema:t=>{const n=h();return T(t,(t,r)=>p(e(t),e=>{n[r]=e})),n}})};export{m as createZodSchematizer};

package/min/schematizers/with-schemas/index.js

@@ -0,0 +1 @@
+