@grasp-labs/ds-microfrontends-integration 0.26.0 → 1.0.0

package/dist/{index.esm-fQDYRCEr-Cx-fegXB.js → index.esm-fQDYRCEr-DmkkBbtV.js}

@@ -1,4 +1,4 @@
-import { O as o } from "./index-oWl7bj7h.js";
+import { O as o } from "./index-B6ZY0zb9.js";
 import { useState as J, useEffect as De, createContext as Zt, useRef as ce, useContext as Gt, useMemo as le, useCallback as Re } from "react";
 const $e = (e, t, n, r, a) => {
   if (!r) throw new Error(a ?? `Invalid property path: ${t}

package/dist/index.js

@@ -1,45 +1,55 @@
-import { A as s, B as r, D as l, c as t, E as i, F as u, a as d, G as o, J as n, L as F, N as g, S as c, T as m, d as p, U as v, V, j as h, k as D, h as P, l as S, x as f, z as b, I as x, n as y, o as G, m as T, p as E, y as I, q as L, g as N, H as R, s as A, t as U, v as j, w as B, C, r as H, u as J, b as O, e as k, f as q, i as w } from "./index-oWl7bj7h.js";
+import { A as s, B as t, D as i, c as r, d as l, E as o, F as d, a as u, G as n, J as c, L as F, N as g, S as m, T as p, e as h, V as P, j as D, k as S, h as f, l as v, R as y, X as V, _ as x, n as b, W as T, o as A, p as G, m as L, q as O, K as R, s as E, t as I, U as N, v as C, g as j, w as B, Z as H, x as J, M as W, y as k, z as q, C as w, H as z, P as K, I as M, Q, Y as U, r as X, u as Y, b as Z, f as _, i as $ } from "./index-B6ZY0zb9.js";
 export {
   s as ArrayField,
-  r as BooleanField,
-  l as DateField,
-  t as DefaultFieldRenderer,
-  i as EnumField,
-  u as FieldError,
-  d as GroupGuard,
-  o as GroupsProvider,
-  n as JsonField,
+  t as BooleanField,
+  i as DateField,
+  r as DefaultFieldRenderer,
+  l as DictionaryField,
+  o as EnumField,
+  d as FieldError,
+  u as GroupGuard,
+  n as GroupsProvider,
+  c as JsonField,
   F as LanguageProvider,
   g as NumberField,
-  c as SchemaFields,
-  m as TextField,
-  p as ToastProvider,
-  v as UserProvider,
-  V as VaultField,
-  h as VaultInput,
-  D as VaultInputField,
-  P as VaultProvider,
-  S as VaultSecretDialog,
-  f as buildDefaultValues,
-  b as createFieldDescriptor,
+  m as SchemaFields,
+  p as TextField,
+  h as ToastProvider,
+  P as VaultField,
+  D as VaultInput,
+  S as VaultInputField,
+  f as VaultProvider,
+  v as VaultSecretDialog,
+  y as buildDefaultValues,
+  V as createFieldDescriptor,
   x as createRuleHandler,
-  y as defineNavigation,
-  G as extractConstraints,
-  T as extractPaths,
-  E as getArrayItemsSchema,
-  I as getDefaultValue,
-  L as getFieldType,
-  N as getLanguage,
-  R as getSchemaResolver,
-  A as isEnumField,
-  U as isNullable,
-  j as isObjectWithoutProperties,
-  B as isReadOnly,
-  C as parseSchemaFields,
-  H as resolveSchema,
-  J as useGroups,
-  O as useLanguage,
-  k as useToast,
-  q as useUser,
-  w as useVault
+  b as defineNavigation,
+  T as evaluateCondition,
+  A as extractConstraints,
+  G as extractDescription,
+  L as extractPaths,
+  O as extractPlaceholder,
+  R as formatLabel,
+  E as getAdditionalPropertiesSchema,
+  I as getArrayItemsSchema,
+  N as getDefaultValue,
+  C as getFieldType,
+  j as getLanguage,
+  B as getPatternPropertiesSchemas,
+  H as getSchemaResolver,
+  J as getTupleSchemas,
+  W as isAnyOfField,
+  k as isDictionary,
+  q as isEnumField,
+  w as isNullable,
+  z as isObjectWithoutProperties,
+  K as isOneOfField,
+  M as isPatternDictionary,
+  Q as isReadOnly,
+  U as parseSchemaFields,
+  X as resolveSchema,
+  Y as useGroups,
+  Z as useLanguage,
+  _ as useToast,
+  $ as useVault
 };

package/dist/lib/schema/conditional.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from 'src/types/Schema';
+export declare function evaluateCondition(ifSchema: Schema, values: unknown): boolean;

package/dist/lib/schema/index.d.ts

@@ -1,6 +1,7 @@
 export type { Constraints, FieldDescriptor, FieldType } from './types';
 export { resolveSchema } from './resolver';
-export { extractConstraints, getArrayItemsSchema, getFieldType, isEnumField, isNullable, isObjectWithoutProperties, isReadOnly, } from './inspector';
+export { extractConstraints, extractDescription, extractPlaceholder, getAdditionalPropertiesSchema, getArrayItemsSchema, getFieldType, getPatternPropertiesSchemas, getTupleSchemas, isDictionary, isEnumField, isNullable, isObjectWithoutProperties, isPatternDictionary, formatLabel, isAnyOfField, isOneOfField, isReadOnly, } from './inspector';
 export { buildDefaultValues, getDefaultValue } from './defaults';
+export { evaluateCondition } from './conditional';
 export { createFieldDescriptor, parseSchemaFields } from './descriptor';
 export { getSchemaResolver, createRuleHandler } from './schemaResolver';

package/dist/lib/schema/inspector.d.ts

@@ -1,10 +1,36 @@
 import { Schema } from 'src/types/Schema';
 import { Constraints, FieldType } from './types';
+/** Returns true if the schema defines a non-empty enum. */
 export declare function isEnumField(schema: Schema): boolean;
+/** Returns true if the field is read-only (const or readOnly). */
 export declare function isReadOnly(schema: Schema): boolean;
+/** Returns true if the schema allows null (nullable, type includes "null", or enum contains null). */
 export declare function isNullable(schema: Schema): boolean;
+/** Returns true for object schemas with no defined properties (dictionary-like). */
 export declare function isObjectWithoutProperties(schema: Schema): boolean;
+/** Returns true for object schemas with patternProperties and no fixed properties. */
+export declare function isPatternDictionary(schema: Schema): boolean;
+/** Extracts pattern → schema map from patternProperties. Returns null if not a pattern dictionary. */
+export declare function getPatternPropertiesSchemas(schema: Schema): Record<string, Schema> | null;
+/** Returns true for object schemas with additionalProperties schema and no fixed properties. */
+export declare function isDictionary(schema: Schema): boolean;
+/** Returns the additionalProperties schema for dictionary-type schemas. */
+export declare function getAdditionalPropertiesSchema(schema: Schema): Schema | null;
+/** Returns true if the schema has a non-empty oneOf composition. */
+export declare function isOneOfField(schema: Schema): boolean;
+/** Returns true if the schema has a non-empty anyOf composition. */
+export declare function isAnyOfField(schema: Schema): boolean;
+/** Determines the FieldType for a schema (e.g., "string", "enum", "tuple", "dictionary"). */
 export declare function getFieldType(schema: Schema): FieldType;
+/** Returns per-position schemas from prefixItems or array items. Null if not a tuple. */
+export declare function getTupleSchemas(schema: Schema): Schema[] | null;
+/** Returns the single items schema for homogeneous arrays. Null for tuples or boolean items. */
 export declare function getArrayItemsSchema(schema: Schema): Schema | null;
+/** Converts a snake_case key to a Title Case label. */
 export declare function formatLabel(key: string): string;
+/** Extracts validation constraints (min, max, pattern, format, etc.) from a schema. */
 export declare function extractConstraints(schema: Schema): Constraints;
+/** Returns the schema description if it's a string. */
+export declare function extractDescription(schema: Schema): string | undefined;
+/** Returns the first example value as a placeholder string. */
+export declare function extractPlaceholder(schema: Schema): string | undefined;

package/dist/lib/schema/resolver.d.ts

@@ -1,2 +1,6 @@
 import { Schema } from 'src/types/Schema';
+/**
+ * Recursively resolves $ref, allOf, oneOf, anyOf, if/then/else, and type-specific
+ * sub-schemas. Tracks visited refs to prevent circular resolution.
+ */
 export declare function resolveSchema(schema: Schema, rootSchema: Schema, visited?: Set<string>): Schema;

package/dist/lib/schema/schemaResolver/schemaResolver.d.ts

@@ -1,4 +1,3 @@
 import { FieldValues, Resolver } from 'react-hook-form';
 import { CustomErrorHandler } from 'src/types';
-import { z } from 'zod';
-export declare const getSchemaResolver: <T extends FieldValues = FieldValues>(schema?: z.core.JSONSchema.JSONSchema, errorHandler?: CustomErrorHandler) => Resolver<T> | undefined;
+export declare const getSchemaResolver: <T extends FieldValues = FieldValues>(schema?: object, errorHandler?: CustomErrorHandler) => Resolver<T> | undefined;

package/dist/lib/schema/schemaResolver/utils.d.ts

@@ -1,10 +1,33 @@
 import { FieldValues, Path } from 'react-hook-form';
-import { CustomErrorHandler, ZodIssue } from 'src/types';
+import { AjvIssue, CustomErrorHandler } from 'src/types';
+/**
+ * AJV error keywords that correspond to validation rules.
+ * Common keywords: type, required, minLength, maxLength, minimum, maximum,
+ * pattern, format, enum, const, if, then, else, anyOf, oneOf, allOf, not
+ */
+export type AjvKeyword = AjvIssue["keyword"];
 export type Rule<TFieldValues extends FieldValues = FieldValues> = {
+    /** Field path to match (e.g., "profile.firstName" or "users.0.email") */
     path?: Path<TFieldValues>;
-    code?: ZodIssue["code"];
-    when?: (issue: ZodIssue) => boolean;
-    message: string | ((issue: ZodIssue) => string);
+    /** AJV keyword to match (e.g., "required", "minLength", "format") */
+    keyword?: AjvKeyword;
+    /** Custom predicate for advanced matching */
+    when?: (issue: AjvIssue) => boolean;
+    /** Error message - static string or function receiving the issue */
+    message: string | ((issue: AjvIssue) => string);
 };
+/**
+ * Gets the full field path from an AJV error.
+ * Handles special cases like "required" where the field is in params.
+ */
+export declare const getFieldPath: (issue: AjvIssue) => string;
 export declare const createRuleHandler: <TFieldValues extends FieldValues = FieldValues>(rules: Rule<TFieldValues>[]) => CustomErrorHandler;
 export declare const convertDatesToStringForValidation: (value: unknown) => unknown;
+/**
+ * Sets a nested error on a FieldErrors object.
+ * Supports dot notation paths like "address.city" or "users.0.email"
+ */
+export declare const setNestedError: (obj: Record<string, unknown>, path: string, error: {
+    type: string;
+    message: string;
+}) => void;

package/dist/lib/schema/types.d.ts

@@ -1,9 +1,11 @@
 import { Schema } from 'src/types/Schema';
-export declare const FIELD_TYPES: readonly ["string", "number", "integer", "boolean", "object", "object-string", "array", "enum", "const", "null", "unknown"];
+export declare const FIELD_TYPES: readonly ["string", "number", "integer", "boolean", "object", "object-string", "dictionary", "pattern-dictionary", "array", "tuple", "enum", "const", "null", "oneOf", "unknown"];
 export type FieldType = (typeof FIELD_TYPES)[number];
 export type Constraints = {
     minimum?: number;
     maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
     minLength?: number;
     maxLength?: number;
     multipleOf?: number;
@@ -21,6 +23,8 @@ export type FieldDescriptor<TFieldName extends string = string> = {
     schema: Schema;
     type: FieldType;
     label: string;
+    description?: string;
+    placeholder?: string;
     isDisabled: boolean;
     required: boolean;
     constraints: Constraints;

package/dist/types/Navigation.d.ts

@@ -13,8 +13,6 @@ export type BaseItem = {
     /**
      * Groups required to access this navigation item.
      * When specified, the item should only be visible to users with all of the listed groups.
-     * Supports glob patterns with wildcard (*) matching exactly one segment,
-     * e.g. "service.store.*" matches "service.store.admin" but not "service.store.admin.extra".
      */
     requiredGroups?: string[];
 };

package/dist/types/Schema.d.ts

@@ -1,6 +1,6 @@
-import { z } from 'zod';
+import { SchemaObject } from 'ajv';
 /**
  * JSON Schema type for validation.
  * Represents a schema for validating objects with unknown properties.
  */
-export type Schema = z.core.JSONSchema.JSONSchema;
+export type Schema = SchemaObject;

package/dist/types/customErrorHandler.d.ts

@@ -1,3 +1,13 @@
-import { default as z } from 'zod';
-export type ZodIssue = z.core.$ZodIssue;
-export type CustomErrorHandler = (issue: ZodIssue) => string | undefined;
+import { ErrorObject } from 'ajv';
+/**
+ * AJV error object with permissive params type to handle all keyword-specific params.
+ * Common params include:
+ * - required: { missingProperty: string }
+ * - minLength/maxLength: { limit: number }
+ * - minimum/maximum: { limit: number, comparison: string }
+ * - pattern: { pattern: string }
+ * - format: { format: string }
+ * - enum: { allowedValues: any[] }
+ */
+export type AjvIssue = ErrorObject<string, Record<string, unknown>, unknown>;
+export type CustomErrorHandler = (issue: AjvIssue) => string | undefined;

package/dist/types/index.d.ts

@@ -4,4 +4,3 @@ export * from './Vault';
 export * from './Groups';
 export * from './Navigation';
 export * from './customErrorHandler';
-export * from './User';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grasp-labs/ds-microfrontends-integration",
-  "version": "0.26.0",
+  "version": "1.0.0",
   "private": false,
   "license": "Apache-2.0",
   "type": "module",
@@ -46,12 +46,13 @@
   },
   "peerDependencies": {
     "@module-federation/vite": "^1.0.0",
+    "ajv": "^8.17.0",
+    "ajv-formats": "^3.0.1",
     "express": "^5.0.0",
     "react": "19.2.3",
     "react-dom": "19.2.3",
     "react-hook-form": "^7.0.0",
-    "react-router": "7.12.0",
-    "zod": "4.2.1"
+    "react-router": "7.12.0"
   },
   "peerDependenciesMeta": {
     "express": {
@@ -60,6 +61,8 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.32.0",
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
     "@grasp-labs/ds-react-components": "^0.23.0",
     "@hookform/resolvers": "^5.2.2",
     "@module-federation/vite": "1.9.4",
@@ -100,7 +103,6 @@
     "vite": "^7.0.6",
     "vite-plugin-dts": "^4.5.4",
     "vite-tsconfig-paths": "^6.0.3",
-    "vitest": "^4.0.16",
-    "zod": "4.2.1"
+    "vitest": "^4.0.16"
   }
 }

package/dist/components/user/UserProvider.d.ts

@@ -1,37 +0,0 @@
-import { ReactNode } from 'react';
-import { User } from '../../types';
-export type UserContextValue = {
-    user: User | null;
-    isAuthenticated: boolean;
-};
-export type UserProviderProps = {
-    children: ReactNode;
-    user: User | null;
-};
-/**
- * Provides user context to child components.
- *
- * @example
- * ```tsx
- * <UserProvider user={user}>
- *   <App />
- * </UserProvider>
- * ```
- */
-export declare const UserProvider: ({ children, user }: UserProviderProps) => import("react/jsx-runtime").JSX.Element;
-/**
- * Hook to access user context.
- *
- * @returns The user context with user data and authentication status.
- * @throws Error if used outside of UserProvider.
- *
- * @example
- * ```tsx
- * const { user, isAuthenticated } = useUser();
- *
- * if (isAuthenticated) {
- *   console.log(user.name);
- * }
- * ```
- */
-export declare const useUser: () => UserContextValue;

package/dist/components/user/UserProvider.stories.d.ts

@@ -1,16 +0,0 @@
-import { StoryObj } from '@storybook/react-vite';
-declare const meta: {
-    title: string;
-    component: ({ children, user }: import('./UserProvider').UserProviderProps) => import("react/jsx-runtime").JSX.Element;
-    parameters: {
-        layout: string;
-    };
-    tags: string[];
-};
-export default meta;
-type Story = StoryObj<typeof meta>;
-export declare const Authenticated: Story;
-export declare const Unauthenticated: Story;
-export declare const PartialUserData: Story;
-export declare const WithCustomFields: Story;
-export declare const LogoutTriggersEffect: StoryObj;

package/dist/components/user/index.d.ts

@@ -1 +0,0 @@
-export * from './UserProvider';

package/dist/types/User.d.ts

@@ -1,5 +0,0 @@
-export type User = {
-    id?: string;
-    name?: string;
-    [key: string]: unknown;
-};