@camera.ui/server 0.0.50-internal.0 → 0.0.50-internal.1

package/src/plugins/schema.ts

@@ -1,472 +0,0 @@
-import { isEqual } from '@camera.ui/common/utils';
-import * as zod from 'zod';
-
-import type {
-  JsonNumberSchema,
-  JsonSchema,
-  JsonSchemaArray,
-  JsonSchemaBoolean,
-  JsonSchemaButton,
-  JsonSchemaEnum,
-  JsonSchemaNumber,
-  JsonSchemaString,
-  JsonSchemaSubmit,
-  JsonSchemaWithoutCallbacks,
-  JsonSchemaWithoutKey,
-  JsonStringSchema,
-} from '@camera.ui/types';
-
-// Type guards for schema identification
-export const isStringType = (schema: JsonSchemaWithoutKey): schema is JsonSchemaString => {
-  return schema.type === 'string' && !('enum' in schema);
-};
-
-export const isNumberType = (schema: JsonSchemaWithoutKey): schema is JsonSchemaNumber => {
-  return schema.type === 'number';
-};
-
-export const isBooleanType = (schema: JsonSchemaWithoutKey): schema is JsonSchemaBoolean => {
-  return schema.type === 'boolean';
-};
-
-export const isEnumType = (schema: JsonSchemaWithoutKey): schema is JsonSchemaEnum => {
-  return schema.type === 'string' && 'enum' in schema;
-};
-
-export const isArrayType = (schema: JsonSchemaWithoutKey): schema is JsonSchemaArray => {
-  return schema.type === 'array';
-};
-
-export const isButtonType = (schema: JsonSchemaWithoutKey): schema is JsonSchemaButton => {
-  return schema.type === 'button';
-};
-
-export const isSubmitType = (schema: JsonSchemaWithoutKey): schema is JsonSchemaSubmit => {
-  return schema.type === 'submit';
-};
-
-export const isValidableStringType = (schema: JsonSchemaWithoutKey): schema is JsonSchemaString => {
-  return isStringType(schema) && (!schema.format || (schema.format !== 'qrCode' && schema.format !== 'image'));
-};
-
-export const isConfigDefault = (config: Record<string, any>, schemas: JsonSchema[]): boolean => {
-  // Early exit for empty config
-  if (!config || Object.keys(config).length === 0) {
-    return true; // Empty config is considered default
-  }
-
-  // Filter out button and submit types as they don't have values
-  const validSchemas = schemas.filter((schema) => !isButtonType(schema) && !isSubmitType(schema));
-
-  // Check each schema field
-  for (const schema of validSchemas) {
-    const currentValue = getValueByKey(config, schema.key);
-    const defaultValue = generateDefaultValue(schema);
-
-    // Skip comparison if the field is not in the config
-    if (currentValue === undefined) continue;
-
-    // Compare values based on type
-    if (!isEqual(currentValue, defaultValue, true)) {
-      return false; // Found a non-default value
-    }
-  }
-
-  return true; // All values match defaults
-};
-
-// Generate default value for a schema field
-export const generateDefaultValue = (schema: JsonSchema): any => {
-  // Return explicit default if provided
-  if ('defaultValue' in schema && schema.defaultValue !== undefined) {
-    return schema.defaultValue;
-  }
-
-  // Generate default based on type
-  switch (schema.type) {
-    case 'string':
-      if (isEnumType(schema)) {
-        return schema.multiple ? [] : schema.required ? schema.enum[0] : '';
-      }
-      return '';
-    case 'number':
-      return 0;
-    case 'boolean':
-      return false;
-    case 'array':
-      return [];
-    default:
-      return undefined;
-  }
-};
-
-// Generate a config object from schema definitions
-export const generateConfigFromSchemas = (schemas: JsonSchema[]): Record<string, any> => {
-  const config: Record<string, any> = {};
-
-  for (const schema of schemas) {
-    // Skip button and submit types as they don't have values
-    if (isButtonType(schema) || isSubmitType(schema)) continue;
-
-    config[schema.key] = generateDefaultValue(schema);
-  }
-
-  return config;
-};
-
-// Get value from config by key
-export const getValueByKey = (config: Record<string, any> = {}, key: string): any => {
-  // For simple keys without nesting
-  if (!key.includes('.') && !key.includes('[')) {
-    return config[key];
-  }
-
-  // For nested keys or array access
-  const keys = key.split('.').reduce<string[]>((acc, part) => {
-    if (part.includes('[')) {
-      const [keyPart, indexPart] = part.split('[');
-      acc.push(keyPart, indexPart.slice(0, -1)); // Remove closing bracket
-    } else {
-      acc.push(part);
-    }
-    return acc;
-  }, []);
-
-  let current = config;
-  for (const k of keys) {
-    if (current === undefined || current === null) {
-      return undefined;
-    }
-    current = current[k];
-  }
-
-  return current;
-};
-
-// Set value in config by key
-export const setValueByKey = (config: Record<string, any>, key: string, value: any): void => {
-  // For simple keys without nesting
-  if (!key.includes('.') && !key.includes('[')) {
-    config[key] = value;
-    return;
-  }
-
-  // For nested keys or array access
-  const keys = key.split('.').reduce<string[]>((acc, part) => {
-    if (part.includes('[')) {
-      const [keyPart, indexPart] = part.split('[');
-      acc.push(keyPart, indexPart.slice(0, -1)); // Remove closing bracket
-    } else {
-      acc.push(part);
-    }
-    return acc;
-  }, []);
-
-  const lastKey = keys.pop();
-  if (!lastKey) return;
-
-  let current = config;
-  for (const k of keys) {
-    if (current[k] === undefined || current[k] === null) {
-      // Create object or array as needed
-      const nextKey = keys[keys.indexOf(k) + 1];
-      current[k] = !isNaN(Number(nextKey)) ? [] : {};
-    }
-    current = current[k];
-  }
-
-  current[lastKey] = value;
-};
-
-// Find schema by key
-export const findSchemaByKey = (schemas: JsonSchema[], key: string): JsonSchema | undefined => {
-  return schemas.find((schema) => schema.key === key);
-};
-
-// Remove callback functions from schema - useful for serialization
-export const removeCallbacksFromSchema = (schema: JsonSchemaWithoutKey): JsonSchemaWithoutCallbacks => {
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const { onSet, onGet, onClick, ...rest } = schema as any;
-
-  if (isArrayType(rest) && rest.items) {
-    rest.items = removeCallbacksFromSchema(rest.items);
-  }
-
-  return rest as JsonSchemaWithoutCallbacks;
-};
-
-// Remove callbacks from all schemas
-export const removeCallbacksFromSchemas = (schemas: JsonSchema[]): JsonSchemaWithoutCallbacks[] => {
-  return schemas.map((schema) => removeCallbacksFromSchema(schema));
-};
-
-// Generate storable config (only include fields with store: true)
-export const generateStorableConfig = (schemas: JsonSchema[], config: Record<string, any>): Record<string, any> => {
-  const storableConfig: Record<string, any> = {};
-
-  for (const schema of schemas) {
-    if ('store' in schema && schema.store && !isButtonType(schema) && !isSubmitType(schema)) {
-      const value = getValueByKey(config, schema.key);
-      if (value !== undefined) {
-        storableConfig[schema.key] = value;
-      }
-    }
-  }
-
-  return storableConfig;
-};
-
-// Check if schema fields have a specific group
-export const getSchemasByGroup = (schemas: JsonSchema[], group: string): JsonSchema[] => {
-  if (!group) return schemas;
-  return schemas.filter((schema) => 'group' in schema && schema.group === group);
-};
-
-// Check if all schemas in a group are readonly
-export const schemaGroupIsReadonly = (schemas: JsonSchema[], group: string): boolean => {
-  const groupSchemas = getSchemasByGroup(schemas, group);
-  return groupSchemas.length > 0 && groupSchemas.every((schema) => 'readonly' in schema && schema.readonly);
-};
-
-// Check if any schema in a group is storable
-export const schemaGroupIsStorable = (schemas: JsonSchema[], group: string): boolean => {
-  const groupSchemas = getSchemasByGroup(schemas, group);
-  return groupSchemas.length > 0 && groupSchemas.some((schema) => 'store' in schema && schema.store);
-};
-
-// Format validation for string types
-export const isValidFormat = (value: string, format?: string): boolean => {
-  if (!format) return true;
-
-  const validations: Record<string, (val: string) => boolean> = {
-    'date-time': (val) => /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(.\d+)?(Z|[+-]\d{2}:\d{2})?$/.test(val),
-    date: (val) => /^\d{4}-\d{2}-\d{2}$/.test(val),
-    time: (val) => /^([01]?[0-9]|2[0-3]):([0-5][0-9])(:([0-5][0-9]))?$/.test(val),
-    email: (val) => /^\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b$/.test(val),
-    uuid: (val) => /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$/.test(val),
-    ipv4: (val) => /^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$/.test(val),
-    ipv6: (val) => /^\s*([0-9a-fA-F]{1,4}:){7}([0-9a-fA-F]{1,4})\s*$/.test(val),
-    // Add more validations as needed
-  };
-
-  return format in validations ? validations[format](value) : true;
-};
-
-// Validate a value against a schema
-export const validateValue = (value: any, schema: JsonSchemaWithoutKey): boolean => {
-  if (isButtonType(schema) || isSubmitType(schema)) return true;
-
-  // Check required fields
-  if ('required' in schema && schema.required && (value === undefined || value === null || value === '')) {
-    return false;
-  }
-
-  switch (schema.type) {
-    case 'string':
-      if (isEnumType(schema)) {
-        if (schema.multiple) {
-          return Array.isArray(value) && value.every((v) => schema.enum.includes(v));
-        } else {
-          return schema.enum.includes(value);
-        }
-      } else {
-        if (typeof value !== 'string') return false;
-        if ((schema as JsonStringSchema).minLength !== undefined && value.length < (schema as JsonStringSchema).minLength!) return false;
-        if ((schema as JsonStringSchema).maxLength !== undefined && value.length > (schema as JsonStringSchema).maxLength!) return false;
-        if ((schema as JsonStringSchema).format) return isValidFormat(value, (schema as JsonStringSchema).format);
-        return true;
-      }
-
-    case 'number':
-      if (typeof value !== 'number') return false;
-      if ((schema as JsonNumberSchema).minimum !== undefined && value < (schema as JsonNumberSchema).minimum!) return false;
-      if ((schema as JsonNumberSchema).maximum !== undefined && value > (schema as JsonNumberSchema).maximum!) return false;
-      return true;
-
-    case 'boolean':
-      return typeof value === 'boolean';
-
-    case 'array':
-      if (!Array.isArray(value)) return false;
-      return value.every((item) => validateValue(item, (schema as JsonSchemaArray).items));
-
-    default:
-      return true;
-  }
-};
-
-// Validate entire config against schema
-export const validateConfig = (config: Record<string, any>, schemas: JsonSchema[]): Record<string, string[]> => {
-  const errors: Record<string, string[]> = {};
-
-  for (const schema of schemas) {
-    // Skip button and submit types
-    if (isButtonType(schema) || isSubmitType(schema)) continue;
-
-    const value = getValueByKey(config, schema.key);
-    const fieldErrors: string[] = [];
-
-    // Required field check
-    if ('required' in schema && schema.required && (value === undefined || value === null || value === '')) {
-      fieldErrors.push('This field is required');
-    }
-
-    // Type-specific validation
-    if (value !== undefined && value !== null) {
-      if (isStringType(schema)) {
-        if (typeof value !== 'string') {
-          fieldErrors.push('Value must be a string');
-        } else {
-          if (schema.minLength !== undefined && value.length < schema.minLength) {
-            fieldErrors.push(`Minimum length is ${schema.minLength}`);
-          }
-          if (schema.maxLength !== undefined && value.length > schema.maxLength) {
-            fieldErrors.push(`Maximum length is ${schema.maxLength}`);
-          }
-          if (schema.format && !isValidFormat(value, schema.format)) {
-            fieldErrors.push(`Invalid ${schema.format} format`);
-          }
-        }
-      } else if (isNumberType(schema)) {
-        if (typeof value !== 'number') {
-          fieldErrors.push('Value must be a number');
-        } else {
-          if (schema.minimum !== undefined && value < schema.minimum) {
-            fieldErrors.push(`Minimum value is ${schema.minimum}`);
-          }
-          if (schema.maximum !== undefined && value > schema.maximum) {
-            fieldErrors.push(`Maximum value is ${schema.maximum}`);
-          }
-        }
-      } else if (isBooleanType(schema)) {
-        if (typeof value !== 'boolean') {
-          fieldErrors.push('Value must be a boolean');
-        }
-      } else if (isEnumType(schema)) {
-        if (schema.multiple) {
-          if (!Array.isArray(value)) {
-            fieldErrors.push('Value must be an array');
-          } else if (!value.every((v) => schema.enum.includes(v))) {
-            fieldErrors.push('Invalid selection');
-          }
-        } else if (!schema.enum.includes(value)) {
-          fieldErrors.push('Invalid selection');
-        }
-      } else if (isArrayType(schema)) {
-        if (!Array.isArray(value)) {
-          fieldErrors.push('Value must be an array');
-        } else {
-          value.forEach((item, index) => {
-            if (!validateValue(item, schema.items)) {
-              fieldErrors.push(`Invalid item at index ${index}`);
-            }
-          });
-        }
-      }
-    }
-
-    if (fieldErrors.length > 0) {
-      errors[schema.key] = fieldErrors;
-    }
-  }
-
-  return errors;
-};
-
-// Generate a Zod schema for a single JSON schema field
-export const generateZodSchemaField = (schema: JsonSchema): zod.ZodTypeAny => {
-  // Skip validation for button and submit types
-  if (isButtonType(schema) || isSubmitType(schema)) {
-    return zod.any();
-  }
-
-  // Build schema based on type
-  switch (schema.type) {
-    case 'string':
-      // Handle enum type
-      if (isEnumType(schema)) {
-        if (schema.multiple) {
-          // Multiple selection
-          let arraySchema = zod.array(zod.string().refine((val) => schema.enum.includes(val), { message: 'Invalid selection' }));
-
-          if (schema.required) {
-            arraySchema = arraySchema.min(1, { message: 'Required' });
-          }
-
-          return schema.required ? arraySchema : arraySchema.optional();
-        } else {
-          // Single selection
-          const enumSchema = zod.enum(schema.enum as [string, ...string[]]);
-          return schema.required ? enumSchema : enumSchema.optional();
-        }
-      }
-
-      // Regular string
-      let strSchema: zod.ZodString | zod.ZodEffects<any, any, any> = zod.string();
-
-      // Add validation for required fields
-      if (schema.required) {
-        strSchema = strSchema.nonempty('Required');
-      }
-
-      // Add length validations
-      if (schema.minLength !== undefined) {
-        strSchema = strSchema.min(schema.minLength);
-      }
-
-      if (schema.maxLength !== undefined) {
-        strSchema = strSchema.max(schema.maxLength);
-      }
-
-      // Add validation for format
-      if (schema.format) {
-        strSchema = strSchema.refine((val) => !val || val.trim() === '' || isValidFormat(val, schema.format), {
-          message: `Invalid ${schema.format} format`,
-        });
-      }
-
-      return schema.required ? strSchema : strSchema.optional();
-
-    case 'number':
-      let numSchema: zod.ZodNumber | zod.ZodEffects<any, any, any> = zod.number();
-
-      if (schema.minimum !== undefined) {
-        numSchema = numSchema.min(schema.minimum);
-      }
-
-      if (schema.maximum !== undefined) {
-        numSchema = numSchema.max(schema.maximum);
-      }
-
-      if (schema.required) {
-        numSchema = numSchema.refine((val) => val !== undefined && val !== null, { message: 'Required' });
-      }
-
-      return schema.required ? numSchema : numSchema.optional();
-
-    case 'boolean':
-      return schema.required ? zod.boolean() : zod.boolean().optional();
-
-    case 'array':
-      const schemaItems = generateZodSchemaField(schema.items as any);
-      const arraySchema = zod.array(schemaItems);
-      return schema.required ? arraySchema : arraySchema.optional();
-
-    default:
-      return (schema as any).required ? zod.any() : zod.any().optional();
-  }
-};
-
-// // Generate a complete Zod schema from an array of JSON schemas
-export const generateZodSchema = (schemas: JsonSchema[]): zod.ZodObject<any> => {
-  const zodSchemaObj: Record<string, zod.ZodTypeAny> = {};
-
-  schemas.forEach((schema) => {
-    // Skip button and submit types as they don't need validation
-    if (!isButtonType(schema) && !isSubmitType(schema)) {
-      zodSchemaObj[schema.key] = generateZodSchemaField(schema);
-    }
-  });
-
-  return zod.object(zodSchemaObj);
-};

package/src/plugins/types.ts

@@ -1,60 +0,0 @@
-import type { Camera, CameraExtension } from '@camera.ui/types';
-
-export interface Context {
-  engines?: Record<string, string>;
-  dependencies?: Record<string, string>;
-}
-
-export const PLUGIN_IDENTIFIER_PATTERN = /^((@[\w-.]*)\/)?(camera-ui-[\w-]*)$/;
-
-export const CAMERA_EXTENSIONS: CameraExtension[] = ['cameraController', 'hub', 'motionDetection', 'objectDetection', 'audioDetection', 'ptz'];
-
-export interface ProcessLoadMessage {
-  cameras: Camera[];
-  plugin: PluginInfo;
-  storage: PluginStorage;
-}
-
-export interface ProcessMessage {
-  type: PLUGIN_COMMAND;
-  data?: ProcessLoadMessage;
-}
-
-export interface ProcessResponse {
-  type: PLUGIN_STATUS;
-  error?: string;
-}
-
-export enum PLUGIN_STATUS {
-  READY = 'ready',
-  STARTING = 'starting',
-  STARTED = 'started',
-  STOPPING = 'stopping',
-  STOPPED = 'stopped',
-  ERROR = 'error',
-  UNKNOWN = 'unknown',
-  DISABLED = 'disabled',
-}
-
-export enum PLUGIN_COMMAND {
-  START = 'start',
-  STOP = 'stop',
-}
-
-export interface PluginStorage {
-  installPath: string;
-  storagePath: string;
-}
-
-export interface PluginInfo {
-  id: string;
-  name: string;
-  contract: PluginContract;
-}
-
-export interface PluginContract {
-  extensions: CameraExtension[];
-  dependencies?: string[];
-  pythonVersion?: string;
-  bundled?: boolean;
-}