@fugood/bricks-ctor 2.24.0-beta.40

package/types/automation.ts

@@ -0,0 +1,235 @@
+/**
+ * Automation (Test) System Types
+ *
+ * This module defines TypeScript types for the BRICKS automation/testing system.
+ * The automation system allows defining automated test sequences that can be
+ * triggered on launch, anytime, or via cron schedules.
+ */
+
+import type { Subspace } from './subspace'
+import type { Brick, Generator } from './common'
+import type { Canvas } from './canvas'
+import type { Data } from './data'
+
+// Entity reference types - can be string ID or getter function
+export type SubspaceRef = string | (() => Subspace)
+export type BrickRef = string | (() => Brick)
+export type GeneratorRef = string | (() => Generator)
+export type CanvasRef = string | (() => Canvas)
+export type DataRef = string | (() => Data)
+
+// Variable types for test variables
+export type TestVariableType = 'string' | 'number' | 'array' | 'object' | 'bool' | 'any'
+
+// Trigger types for when tests should run
+export type TestTriggerType = 'launch' | 'anytime' | 'cron'
+
+// Jump condition operators for conditional test flow
+export type JumpConditionOperator = '==' | '!=' | '>' | '>=' | '<' | '<='
+
+// Jump condition status types
+export type JumpConditionStatus = 'finished' | 'failed'
+
+// Jump condition types
+export type JumpConditionType = 'status' | 'variable'
+
+/**
+ * Jump condition for controlling test case flow
+ */
+export interface TestCaseJumpCondition {
+  type: JumpConditionType
+  // For status-based conditions
+  status?: JumpConditionStatus
+  // For variable-based conditions
+  variable?: string
+  operator?: JumpConditionOperator
+  value?: any
+  // The test case to jump to (getter function for dynamic IDs or string for static IDs)
+  jump_to?: string | (() => TestCase)
+}
+
+/**
+ * Test variable definition
+ */
+export interface TestVariable {
+  __typename: 'TestVariable'
+  id: string
+  name: string
+  type: TestVariableType
+  value: any
+}
+
+/**
+ * Post delay rules for test cases
+ */
+export type PostDelayRule = 'include-action-time' | 'exclude-action-time'
+
+/**
+ * Test method names (13 methods)
+ */
+export type TestMethodName =
+  | 'brick_press'
+  | 'brick_exists'
+  | 'wait_until_brick_exists'
+  | 'wait_until_event_trigger'
+  | 'wait_until_canvas_change'
+  | 'keydown'
+  | 'keyup'
+  | 'http_request'
+  | 'assert_property'
+  | 'wait_until_property_change'
+  | 'execute_action'
+  | 'match_screenshot'
+  | 'delay'
+
+/**
+ * Run array types for each test method
+ * Each method has a specific signature: [methodName, ...args]
+ */
+
+// [methodName, subspaceId, brickId, options?]
+export type TestMethodRunBrickPress = ['brick_press', SubspaceRef, BrickRef, Record<string, any>?]
+
+// [methodName, subspaceId, brickId, frame?]
+export type TestMethodRunBrickExists = ['brick_exists', SubspaceRef, BrickRef, Record<string, any>?]
+
+// [methodName, subspaceId, brickId, timeout?, frame?]
+export type TestMethodRunWaitUntilBrickExists = [
+  'wait_until_brick_exists',
+  SubspaceRef,
+  BrickRef,
+  number?,
+  Record<string, any>?,
+]
+
+// [methodName, subspaceId, senderId, eventKey, timeout?]
+// senderId can be brick or generator
+export type TestMethodRunWaitUntilEventTrigger = [
+  'wait_until_event_trigger',
+  SubspaceRef,
+  BrickRef | GeneratorRef,
+  string,
+  number?,
+]
+
+// [methodName, subspaceId, canvasId, timeout?]
+export type TestMethodRunWaitUntilCanvasChange = [
+  'wait_until_canvas_change',
+  SubspaceRef,
+  CanvasRef,
+  number?,
+]
+
+// [methodName, keyCode, pressedKey?, flags?]
+export type TestMethodRunKeydown = ['keydown', number, string?, number?]
+
+// [methodName, keyCode, pressedKey?, flags?]
+export type TestMethodRunKeyup = ['keyup', number, string?, number?]
+
+// [methodName, url, options?]
+export type TestMethodRunHttpRequest = ['http_request', string, Record<string, any>?]
+
+// [methodName, subspaceId, propertyId, value]
+export type TestMethodRunAssertProperty = ['assert_property', SubspaceRef, DataRef, any]
+
+// [methodName, subspaceId, propertyId, value, timeout?]
+export type TestMethodRunWaitUntilPropertyChange = [
+  'wait_until_property_change',
+  SubspaceRef,
+  DataRef,
+  any,
+  number?,
+]
+
+// [methodName, subspaceId, handler, action, params?, options?]
+export type TestMethodRunExecuteAction = [
+  'execute_action',
+  SubspaceRef,
+  string,
+  string,
+  Record<string, any>?,
+  Record<string, any>?,
+]
+
+// [methodName, screenshotName, threshold?, maxRetry?]
+export type TestMethodRunMatchScreenshot = ['match_screenshot', string, number?, number?]
+
+// [methodName, subspaceId?, propertyId?, defaultValue?]
+export type TestMethodRunDelay = ['delay', SubspaceRef?, DataRef?, number?]
+
+/**
+ * Union type for all test method run arrays
+ */
+export type TestMethodRun =
+  | TestMethodRunBrickPress
+  | TestMethodRunBrickExists
+  | TestMethodRunWaitUntilBrickExists
+  | TestMethodRunWaitUntilEventTrigger
+  | TestMethodRunWaitUntilCanvasChange
+  | TestMethodRunKeydown
+  | TestMethodRunKeyup
+  | TestMethodRunHttpRequest
+  | TestMethodRunAssertProperty
+  | TestMethodRunWaitUntilPropertyChange
+  | TestMethodRunExecuteAction
+  | TestMethodRunMatchScreenshot
+  | TestMethodRunDelay
+
+/**
+ * Test case definition
+ */
+export interface TestCase {
+  __typename: 'TestCase'
+  id: string
+  name: string
+  hideShortRef?: boolean
+  run: TestMethodRun
+  exit_on_failed: boolean
+  commented: boolean
+  pre_delay: number
+  post_delay: number
+  post_delay_rule?: PostDelayRule
+  jump_cond: TestCaseJumpCondition[]
+}
+
+/**
+ * Local sync mode for tests
+ */
+export type LocalSyncMode = 'main-only' | 'minor-only'
+
+/**
+ * Automation test definition
+ */
+export interface AutomationTest {
+  __typename: 'AutomationTest'
+  id: string
+  title: string
+  hideShortRef?: boolean
+  timeout: number
+  trigger_type?: TestTriggerType
+  cron?: string // Cron expression when trigger_type is 'cron'
+  skip_trigger_type_check?: boolean
+  local_sync?: LocalSyncMode
+  cases: TestCase[]
+  variables: TestVariable[]
+  meta?: Record<string, any>
+}
+
+/**
+ * Automation test map (a collection of tests)
+ */
+export interface AutomationTestMap {
+  __typename: 'AutomationTestMap'
+  id: string
+  title: string
+  hideShortRef?: boolean
+  createdAt: number
+  tests: AutomationTest[]
+}
+
+/**
+ * Root automation map type (record of automation test maps by ID)
+ */
+export type AutomationMap = {
+  [mapId: string]: AutomationTestMap
+}

package/types/brick-base.ts

@@ -0,0 +1,80 @@
+/* Auto generated by build script */
+import type { SwitchCondInnerStateCurrentCanvas, SwitchCondData, SwitchDef } from './switch'
+import type { Data, DataLink } from './data'
+import type { Animation, AnimationBasicEvents } from './animation'
+import type {
+  Brick,
+  EventAction,
+  EventActionForItem,
+  ActionWithDataParams,
+  ActionWithParams,
+  Action,
+  EventProperty,
+} from './common'
+
+export interface BrickBasicProperty {
+  /* The brick opacity (0 ~ 1) */
+  opacity?: number | DataLink
+  /* The brick background color */
+  backgroundColor?: string | DataLink
+  /* The brick border style */
+  borderStyle?: 'solid' | 'dotted' | 'dashed' | DataLink
+  /* The brick border width (top) */
+  borderTopSize?: number | DataLink
+  /* The brick border color (top) */
+  borderTopColor?: string | DataLink
+  /* The brick border radius (top left) */
+  borderTopLeftRadius?: number | DataLink
+  /* The brick border radius (top right) */
+  borderTopRightRadius?: number | DataLink
+  /* The brick border width (bottom) */
+  borderBottomSize?: number | DataLink
+  /* The brick border color (bottom) */
+  borderBottomColor?: string | DataLink
+  /* The brick border radius (bottom left) */
+  borderBottomLeftRadius?: number | DataLink
+  /* The brick border radius (bottom right) */
+  borderBottomRightRadius?: number | DataLink
+  /* The brick border width (left) */
+  borderLeftSize?: number | DataLink
+  /* The brick border color (bottom) */
+  borderLeftColor?: string | DataLink
+  /* The brick border width (right) */
+  borderRightSize?: number | DataLink
+  /* The brick border color (right) */
+  borderRightColor?: string | DataLink
+  /* The brick rotate (deg) */
+  rotate?: number | DataLink
+  /* The brick rotateX (deg) */
+  rotateX?: number | DataLink
+  /* The brick rotateY (deg) */
+  rotateY?: number | DataLink
+  /* The brick shadow color */
+  shadowColor?: string | DataLink
+  /* The brick shadow opacity (0 ~ 1) */
+  shadowOpacity?: number | DataLink
+  /* The brick shadow radius */
+  shadowRadius?: number | DataLink
+  /* The brick shadow offset width */
+  shadowOffsetWidth?: number | DataLink
+  /* The brick shadow offset height */
+  shadowOffsetHeight?: number | DataLink
+  /* Brick pressable.
+ Disabled: Disabled even if event or animation is set.  
+ Bypass: Disable and bypass the touch event on the brick. */
+  pressable?: 'enabled' | 'disabled' | 'bypass' | DataLink
+  /* Delay in milliseconds before long press is triggered */
+  delayLongPress?: number | DataLink
+}
+
+export interface BrickBasicEvents {
+  showStart?: Array<EventAction>
+  switchUpdate?: Array<EventAction>
+  standby?: Array<EventAction>
+}
+
+export interface BrickBasicEventsForItem {
+  showStart?: Array<EventActionForItem>
+  switchUpdate?: Array<EventActionForItem>
+  standby?: Array<EventActionForItem>
+}

package/types/bricks/Camera.ts

@@ -0,0 +1,246 @@
+/* Auto generated by build script
+ *
+ * Camera view with photo capture and barcode scanning capabilities
+ */
+import type { SwitchCondInnerStateCurrentCanvas, SwitchCondData, SwitchDef } from '../switch'
+import type { Data, DataLink } from '../data'
+import type { Animation, AnimationBasicEvents } from '../animation'
+import type {
+  Brick,
+  EventAction,
+  EventActionForItem,
+  ActionWithDataParams,
+  ActionWithParams,
+  Action,
+  EventProperty,
+} from '../common'
+import type { BrickBasicProperty, BrickBasicEvents, BrickBasicEventsForItem } from '../brick-base'
+import type { TemplateEventPropsMap } from '../../utils/event-props'
+
+/* Take picture on the Camera */
+export type BrickCameraActionTakePicture = ActionWithParams & {
+  __actionName: 'BRICK_CAMERA_TAKE_PICTURE'
+  params?: Array<
+    | {
+        input: 'width'
+        value?: number | DataLink | EventProperty
+        mapping?: string
+      }
+    | {
+        input: 'quality'
+        value?: string | DataLink | EventProperty
+        mapping?: string
+      }
+    | {
+        input: 'base64'
+        value?: boolean | DataLink | EventProperty
+        mapping?: string
+      }
+    | {
+        input: 'mirrorImage'
+        value?: boolean | DataLink | EventProperty
+        mapping?: string
+      }
+  >
+}
+
+/* Record video on the Camera */
+export type BrickCameraActionRecord = ActionWithParams & {
+  __actionName: 'BRICK_CAMERA_RECORD'
+  params?: Array<
+    | {
+        input: 'quality'
+        value?: '4:3' | '288p' | '480p' | '720p' | '1080p' | '2160p' | DataLink | EventProperty
+        mapping?: string
+      }
+    | {
+        input: 'mirrorVideo'
+        value?: boolean | DataLink | EventProperty
+        mapping?: string
+      }
+    | {
+        input: 'videoBitrate'
+        value?: string | DataLink | EventProperty
+        mapping?: string
+      }
+    | {
+        input: 'maxDuration'
+        value?: number | DataLink | EventProperty
+        mapping?: string
+      }
+    | {
+        input: 'maxFileSize'
+        value?: string | DataLink | EventProperty
+        mapping?: string
+      }
+  >
+}
+
+/* Record video on the Camera */
+export type BrickCameraActionStopRecord = Action & {
+  __actionName: 'BRICK_CAMERA_STOP_RECORD'
+}
+
+/* Focus the Camera at a specific point */
+export type BrickCameraActionFocus = ActionWithParams & {
+  __actionName: 'BRICK_CAMERA_FOCUS'
+  params?: Array<
+    | {
+        input: 'focusX'
+        value?: number | DataLink | EventProperty
+        mapping?: string
+      }
+    | {
+        input: 'focusY'
+        value?: number | DataLink | EventProperty
+        mapping?: string
+      }
+  >
+}
+
+interface BrickCameraDef {
+  /*
+Default property:
+{
+  "type": "back",
+  "flashMode": "off",
+  "captureAudio": false,
+  "whiteBalance": "auto",
+  "faceDetectionEnabled": false,
+  "faceDetectionEventMode": "when-detected"
+}
+  */
+  property?: BrickBasicProperty & {
+    /* Camera type */
+    type?: 'back' | 'front' | 'external' | DataLink
+    /* Enable or disable camera */
+    isActive?: boolean | DataLink
+    /* Camera zoom */
+    zoom?: number | DataLink
+    /* Camera flash mode */
+    flashMode?: 'off' | 'on' | 'torch' | 'auto' | DataLink
+    /* Camera ratio (Unsupported ratio will be ignored) */
+    ratio?: string | DataLink
+    /* Capture audio when start recording */
+    captureAudio?: boolean | DataLink
+    /* Allows you to control the color temperature in your photos by cooling down or warming up the colors. */
+    whiteBalance?:
+      | 'auto'
+      | 'sunny'
+      | 'cloudy'
+      | 'shadow'
+      | 'incandescent'
+      | 'fluorescent'
+      | DataLink
+    /* Enable face detection (Note: Barcode detection will be disabled when enabled) */
+    faceDetectionEnabled?: boolean | DataLink
+    /* Face detection event mode */
+    faceDetectionEventMode?: 'when-detected' | 'interval' | DataLink
+    /* Quality of take picture */
+    pictureQuality?: number | DataLink
+    /* Take picture format as base64 */
+    pictureBase64?: boolean | DataLink
+    /* Mirror image of take picture */
+    pictureIsMirrorImage?: boolean | DataLink
+    /* Quality of record video */
+    recordQuality?: '4:3' | '288p' | '480p' | '720p' | '1080p' | '2160p' | DataLink
+    /* Bitrate of record video (bit/s) */
+    recordVideoBitrate?: number | DataLink
+    /* Mirror video of record video */
+    recordMirrorVideo?: boolean | DataLink
+    /* Max duration of record video (s) */
+    recordMaxDuration?: number | DataLink
+    /* Max file size of record video (bytes) */
+    recordMaxFileSize?: number | DataLink
+  }
+  events?: BrickBasicEvents & {
+    /* Event of the Camera state change */
+    stateChange?: Array<EventAction<string & keyof TemplateEventPropsMap['Camera']['stateChange']>>
+    /* Event of the Camera record start */
+    recordStart?: Array<EventAction>
+    /* Event of the Camera record end */
+    recordEnd?: Array<EventAction>
+    /* Event of the Camera barcode read */
+    barcodeRead?: Array<EventAction<string & keyof TemplateEventPropsMap['Camera']['barcodeRead']>>
+    /* Event of the Camera picture taken */
+    pictureTaken?: Array<
+      EventAction<string & keyof TemplateEventPropsMap['Camera']['pictureTaken']>
+    >
+    /* Event of the Camera record finished */
+    recordFinish?: Array<
+      EventAction<string & keyof TemplateEventPropsMap['Camera']['recordFinish']>
+    >
+    /* Event of the Camera mount error */
+    mountError?: Array<EventAction<string & keyof TemplateEventPropsMap['Camera']['mountError']>>
+  }
+  outlets?: {
+    /* Camera device and format information */
+    info?: () => Data<{ [key: string]: any }>
+    /* Picture taken result */
+    pictureTaken?: () => Data<{
+      width?: number
+      height?: number
+      uri?: string
+      base64?: string
+      [key: string]: any
+    }>
+    /* Record video result */
+    recordVideo?: () => Data<{
+      uri?: string
+      [key: string]: any
+    }>
+    /* Barcode read result */
+    barcodeRead?: () => Data<{
+      type?: string
+      data?: string
+      rawData?: string
+      bounds?: {
+        origin?: {
+          x?: number
+          y?: number
+          [key: string]: any
+        }
+        size?: {
+          width?: number
+          height?: number
+          [key: string]: any
+        }
+        [key: string]: any
+      }
+      [key: string]: any
+    }>
+    /* Faces detected result */
+    faceDetected?: () => Data<Array<{ [key: string]: any }>>
+  }
+  animation?: AnimationBasicEvents & {
+    stateChange?: Animation
+    recordStart?: Animation
+    recordEnd?: Animation
+    barcodeRead?: Animation
+    pictureTaken?: Animation
+    recordFinish?: Animation
+    mountError?: Animation
+  }
+}
+
+/* Camera view with photo capture and barcode scanning capabilities */
+export type BrickCamera = Brick &
+  BrickCameraDef & {
+    templateKey: 'BRICK_CAMERA'
+    switches?: Array<
+      SwitchDef &
+        BrickCameraDef & {
+          conds?: Array<{
+            method: '==' | '!=' | '>' | '<' | '>=' | '<='
+            cond:
+              | SwitchCondInnerStateCurrentCanvas
+              | SwitchCondData
+              | {
+                  __typename: 'SwitchCondInnerStateOutlet'
+                  outlet: 'info' | 'pictureTaken' | 'recordVideo' | 'barcodeRead' | 'faceDetected'
+                  value: any
+                }
+          }>
+        }
+    >
+  }