ai-props 2.1.3 → 2.4.0

package/src/hoc.js

@@ -1,235 +0,0 @@
-/**
- * Higher-Order Component (HOC) for React components
- *
- * Provides withAIProps HOC for wrapping React components
- * with AI-powered prop generation.
- *
- * @packageDocumentation
- */
-import { generateProps, mergeWithGenerated } from './generate.js';
-/**
- * Create props wrapper that can be used with any component system
- *
- * This is framework-agnostic and returns the enhanced props.
- *
- * @example
- * ```ts
- * const enhancer = createPropsEnhancer({
- *   schema: {
- *     title: 'Page title',
- *     description: 'Page description',
- *   },
- *   defaults: {
- *     title: 'Default Title',
- *   },
- * })
- *
- * // Use with any component
- * const props = await enhancer({ description: 'My page' })
- * // { title: 'Default Title', description: 'My page' }
- *
- * const generatedProps = await enhancer({})
- * // { title: 'AI-generated title', description: 'AI-generated description' }
- * ```
- */
-export function createPropsEnhancer(options) {
-    const { schema, defaults = {}, required = [], exclude = [], config = {}, fallback } = options;
-    return async (partialProps) => {
-        try {
-            // Merge with defaults
-            const propsWithDefaults = { ...defaults, ...partialProps };
-            // Check required props
-            const missingRequired = required.filter(key => propsWithDefaults[key] === undefined);
-            if (missingRequired.length > 0) {
-                throw new Error(`Missing required props: ${missingRequired.join(', ')}`);
-            }
-            // Filter out excluded props from schema
-            const filteredSchema = filterSchemaKeys(schema, exclude);
-            // Generate missing props
-            return await mergeWithGenerated(filteredSchema, propsWithDefaults, {
-                model: config.model,
-                system: config.system,
-            });
-        }
-        catch (error) {
-            if (fallback) {
-                return { ...defaults, ...fallback, ...partialProps };
-            }
-            throw error;
-        }
-    };
-}
-/**
- * Filter schema to exclude certain keys
- */
-function filterSchemaKeys(schema, exclude) {
-    if (typeof schema === 'string' || exclude.length === 0) {
-        return schema;
-    }
-    const filtered = {};
-    for (const [key, value] of Object.entries(schema)) {
-        if (!exclude.includes(key)) {
-            filtered[key] = value;
-        }
-    }
-    return filtered;
-}
-/**
- * Create an async props provider
- *
- * Returns a function that generates props on each call.
- * Useful for SSR and static generation.
- *
- * @example
- * ```ts
- * const getPageProps = createAsyncPropsProvider({
- *   schema: {
- *     title: 'SEO-optimized page title',
- *     meta: { description: 'Meta description' },
- *   },
- * })
- *
- * // In getStaticProps or getServerSideProps
- * export async function getStaticProps() {
- *   const props = await getPageProps({ slug: 'about' })
- *   return { props }
- * }
- * ```
- */
-export function createAsyncPropsProvider(options) {
-    const enhancer = createPropsEnhancer(options);
-    return {
-        /**
-         * Get props with AI generation
-         */
-        getProps: enhancer,
-        /**
-         * Get props for multiple items
-         */
-        getManyProps: async (contexts) => {
-            return Promise.all(contexts.map(enhancer));
-        },
-        /**
-         * Get props with caching hint
-         */
-        getCachedProps: async (context, revalidate) => {
-            const props = await enhancer(context);
-            return { props, revalidate };
-        },
-    };
-}
-/**
- * Create a props transformer
- *
- * Transforms existing props by filling in missing values.
- *
- * @example
- * ```ts
- * const transformUserProps = createPropsTransformer({
- *   schema: {
- *     displayName: 'Display name for the user',
- *     initials: 'User initials (2 letters)',
- *   },
- * })
- *
- * const user = await transformUserProps({
- *   username: 'johndoe',
- *   email: 'john@example.com',
- * })
- * // { username: 'johndoe', email: '...', displayName: 'John Doe', initials: 'JD' }
- * ```
- */
-export function createPropsTransformer(options) {
-    const { schema, transform, config = {} } = options;
-    return async (input) => {
-        const result = await generateProps({
-            schema,
-            context: input,
-            model: config.model,
-            system: config.system,
-        });
-        const generated = result.props;
-        if (transform) {
-            return { ...input, ...transform(input, generated) };
-        }
-        return { ...input, ...generated };
-    };
-}
-/**
- * Create a conditional props generator
- *
- * Only generates props when a condition is met.
- *
- * @example
- * ```ts
- * const maybeGenerateProps = createConditionalGenerator({
- *   schema: { summary: 'Article summary' },
- *   condition: (props) => !props.summary && props.content?.length > 100,
- * })
- * ```
- */
-export function createConditionalGenerator(options) {
-    const { schema, condition, config = {} } = options;
-    return async (props) => {
-        if (!condition(props)) {
-            return props;
-        }
-        return mergeWithGenerated(schema, props, {
-            model: config.model,
-            system: config.system,
-        });
-    };
-}
-/**
- * Batch props generator for list rendering
- *
- * Efficiently generates props for multiple items.
- *
- * @example
- * ```ts
- * const batchGenerator = createBatchGenerator({
- *   schema: { title: 'Item title', description: 'Item description' },
- * })
- *
- * const items = await batchGenerator.generate([
- *   { id: 1, category: 'tech' },
- *   { id: 2, category: 'science' },
- *   { id: 3, category: 'art' },
- * ])
- * ```
- */
-export function createBatchGenerator(options) {
-    const { schema, concurrency = 3, config = {} } = options;
-    return {
-        /**
-         * Generate props for multiple items
-         */
-        generate: async (items) => {
-            const results = [];
-            // Process in batches based on concurrency
-            for (let i = 0; i < items.length; i += concurrency) {
-                const batch = items.slice(i, i + concurrency);
-                const batchResults = await Promise.all(batch.map(item => mergeWithGenerated(schema, item, {
-                    model: config.model,
-                    system: config.system,
-                })));
-                results.push(...batchResults);
-            }
-            return results;
-        },
-        /**
-         * Generate props one at a time (for rate limiting)
-         */
-        generateSequential: async (items) => {
-            const results = [];
-            for (const item of items) {
-                const result = await mergeWithGenerated(schema, item, {
-                    model: config.model,
-                    system: config.system,
-                });
-                results.push(result);
-            }
-            return results;
-        },
-    };
-}

package/src/index.js

@@ -1,20 +0,0 @@
-/**
- * ai-props - AI-powered props for intelligent component properties
- *
- * This package provides utilities for automatically generating
- * component props using AI based on schema definitions.
- *
- * @packageDocumentation
- */
-// Export types
-export * from './types.js';
-// Export core functionality
-export { AI, createAIComponent, definePropsSchema, createComponentFactory, composeAIComponents, } from './ai.js';
-// Export generation functions
-export { generateProps, getPropsSync, prefetchProps, generatePropsMany, mergeWithGenerated, configureAIProps, getConfig, resetConfig, } from './generate.js';
-// Export cache utilities
-export { MemoryPropsCache, LRUPropsCache, createCacheKey, getDefaultCache, configureCache, clearCache, DEFAULT_CACHE_TTL, } from './cache.js';
-// Export HOC and enhancers
-export { createPropsEnhancer, createAsyncPropsProvider, createPropsTransformer, createConditionalGenerator, createBatchGenerator, } from './hoc.js';
-// Export validation utilities
-export { validateProps, hasRequiredProps, getMissingProps, isComplete, getMissingFromSchema, sanitizeProps, mergeWithDefaults, createValidator, assertValidProps, } from './validate.js';

package/src/types.js

@@ -1,6 +0,0 @@
-/**
- * Type definitions for ai-props
- *
- * @packageDocumentation
- */
-export {};

package/src/validate.js

@@ -1,252 +0,0 @@
-/**
- * Validation utilities for ai-props
- *
- * Provides prop validation against schemas.
- *
- * @packageDocumentation
- */
-/**
- * Validate props against a schema
- *
- * @example
- * ```ts
- * const result = validateProps(
- *   { name: 'John', age: '25' },  // props
- *   { name: 'Name', age: 'Age (number)' }  // schema
- * )
- *
- * if (!result.valid) {
- *   console.log(result.errors)
- *   // [{ path: 'age', message: 'Expected number, got string' }]
- * }
- * ```
- */
-export function validateProps(props, schema) {
-    const errors = [];
-    if (typeof schema === 'string') {
-        // Simple string schema - just check if value exists
-        if (!props.value) {
-            errors.push({
-                path: 'value',
-                message: 'Value is required',
-                expected: 'string',
-                received: props.value,
-            });
-        }
-        return { valid: errors.length === 0, errors };
-    }
-    // Object schema - validate each key
-    for (const [key, schemaDef] of Object.entries(schema)) {
-        const value = props[key];
-        const keyErrors = validateValue(key, value, schemaDef);
-        errors.push(...keyErrors);
-    }
-    return { valid: errors.length === 0, errors };
-}
-/**
- * Validate a single value against a schema definition
- */
-function validateValue(path, value, schema) {
-    const errors = [];
-    // String schema with type hint
-    if (typeof schema === 'string') {
-        const expectedType = extractTypeFromSchema(schema);
-        if (value === undefined || value === null) {
-            // Optional unless marked required
-            return errors;
-        }
-        if (expectedType && !checkType(value, expectedType)) {
-            errors.push({
-                path,
-                message: `Expected ${expectedType}, got ${typeof value}`,
-                expected: expectedType,
-                received: value,
-            });
-        }
-        return errors;
-    }
-    // Array schema
-    if (Array.isArray(schema)) {
-        if (!Array.isArray(value)) {
-            if (value !== undefined && value !== null) {
-                errors.push({
-                    path,
-                    message: `Expected array, got ${typeof value}`,
-                    expected: 'array',
-                    received: value,
-                });
-            }
-            return errors;
-        }
-        // Validate array items if schema has item definition
-        if (schema.length > 0) {
-            const itemSchema = schema[0];
-            for (let i = 0; i < value.length; i++) {
-                const itemErrors = validateValue(`${path}[${i}]`, value[i], itemSchema);
-                errors.push(...itemErrors);
-            }
-        }
-        return errors;
-    }
-    // Object schema
-    if (typeof schema === 'object' && schema !== null) {
-        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-            if (value !== undefined && value !== null) {
-                errors.push({
-                    path,
-                    message: `Expected object, got ${Array.isArray(value) ? 'array' : typeof value}`,
-                    expected: 'object',
-                    received: value,
-                });
-            }
-            return errors;
-        }
-        // Recursively validate nested object
-        for (const [key, nestedSchema] of Object.entries(schema)) {
-            const nestedValue = value[key];
-            const nestedErrors = validateValue(`${path}.${key}`, nestedValue, nestedSchema);
-            errors.push(...nestedErrors);
-        }
-    }
-    return errors;
-}
-/**
- * Extract type hint from schema string
- * e.g., "Age (number)" -> "number"
- */
-function extractTypeFromSchema(schema) {
-    const match = schema.match(/\((\w+)\)\s*$/);
-    if (match) {
-        return match[1].toLowerCase();
-    }
-    // Check for enum syntax
-    if (schema.includes(' | ')) {
-        return 'enum';
-    }
-    return null;
-}
-/**
- * Check if a value matches an expected type
- */
-function checkType(value, expectedType) {
-    switch (expectedType) {
-        case 'string':
-            return typeof value === 'string';
-        case 'number':
-        case 'integer':
-            return typeof value === 'number';
-        case 'boolean':
-            return typeof value === 'boolean';
-        case 'array':
-            return Array.isArray(value);
-        case 'object':
-            return typeof value === 'object' && value !== null && !Array.isArray(value);
-        case 'date':
-            return typeof value === 'string' || value instanceof Date;
-        case 'enum':
-            return typeof value === 'string';
-        default:
-            return true;
-    }
-}
-/**
- * Check if all required props are present
- */
-export function hasRequiredProps(props, required) {
-    return required.every(key => props[key] !== undefined);
-}
-/**
- * Get list of missing required props
- */
-export function getMissingProps(props, required) {
-    return required.filter(key => props[key] === undefined);
-}
-/**
- * Check if props are complete according to schema
- */
-export function isComplete(props, schema) {
-    if (typeof schema === 'string') {
-        return props.value !== undefined;
-    }
-    return Object.keys(schema).every(key => props[key] !== undefined);
-}
-/**
- * Get list of missing props according to schema
- */
-export function getMissingFromSchema(props, schema) {
-    if (typeof schema === 'string') {
-        return props.value === undefined ? ['value'] : [];
-    }
-    return Object.keys(schema).filter(key => props[key] === undefined);
-}
-/**
- * Sanitize props by removing extra keys not in schema
- */
-export function sanitizeProps(props, schema) {
-    if (typeof schema === 'string') {
-        return { value: props.value };
-    }
-    const schemaKeys = new Set(Object.keys(schema));
-    const sanitized = {};
-    for (const [key, value] of Object.entries(props)) {
-        if (schemaKeys.has(key)) {
-            sanitized[key] = value;
-        }
-    }
-    return sanitized;
-}
-/**
- * Merge props with defaults, respecting schema types
- */
-export function mergeWithDefaults(props, defaults, schema) {
-    const result = { ...defaults, ...props };
-    // Ensure types match schema
-    if (typeof schema !== 'string') {
-        for (const [key, schemaDef] of Object.entries(schema)) {
-            if (result[key] === undefined)
-                continue;
-            const expectedType = typeof schemaDef === 'string'
-                ? extractTypeFromSchema(schemaDef)
-                : null;
-            if (expectedType) {
-                result[key] = coerceType(result[key], expectedType);
-            }
-        }
-    }
-    return result;
-}
-/**
- * Attempt to coerce a value to an expected type
- */
-function coerceType(value, expectedType) {
-    if (value === undefined || value === null)
-        return value;
-    switch (expectedType) {
-        case 'string':
-            return String(value);
-        case 'number':
-            return typeof value === 'number' ? value : Number(value);
-        case 'integer':
-            return typeof value === 'number' ? Math.floor(value) : parseInt(String(value), 10);
-        case 'boolean':
-            return Boolean(value);
-        default:
-            return value;
-    }
-}
-/**
- * Create a props validator function
- */
-export function createValidator(schema) {
-    return (props) => validateProps(props, schema);
-}
-/**
- * Assert props are valid, throwing on error
- */
-export function assertValidProps(props, schema) {
-    const result = validateProps(props, schema);
-    if (!result.valid) {
-        const messages = result.errors.map(e => `${e.path}: ${e.message}`).join(', ');
-        throw new Error(`Invalid props: ${messages}`);
-    }
-}