feat(blocks): add text2speech translate and video sensing extension blocks

Co-authored-by: chatgpt-codex-connector[bot] <199175422+chatgpt-codex-connector[bot]@users.noreply.github.com>

Author: nakasyou

packages/hikkaku/src/blocks/index.ts

@@ -9,3 +9,6 @@ export * from './pen'
 export * from './procedures'
 export * from './sensing'
 export * from './sound'
+export * from './text2speech'
+export * from './translate'
+export * from './videosensing'

packages/hikkaku/src/blocks/text2speech.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, test } from 'vite-plus/test'
+import { block, createBlocks } from '../core/composer'
+import { setLanguage, setVoice, speakAndWait } from './text2speech'
+
+describe('blocks/text2speech', () => {
+  test('creates text to speech extension blocks', () => {
+    const blocks = createBlocks(() => {
+      block('event_whenflagclicked', { topLevel: true })
+      setVoice('TENOR')
+      setLanguage('ja')
+      speakAndWait('hello')
+    })
+
+    const opcodes = Object.values(blocks).map((b) => b.opcode)
+    expect(opcodes).toContain('text2speech_setVoice')
+    expect(opcodes).toContain('text2speech_setLanguage')
+    expect(opcodes).toContain('text2speech_speakAndWait')
+  })
+})

packages/hikkaku/src/blocks/text2speech.ts

@@ -0,0 +1,36 @@
+import { InputType } from 'sb3-types/enum'
+import { fromPrimitiveSource } from '../core/block-helper'
+import { block } from '../core/composer'
+import type { HikkakuString, PrimitiveSource } from '../core/types'
+
+export type TextToSpeechVoice =
+  | 'ALTO'
+  | 'TENOR'
+  | 'SQUEAK'
+  | 'GIANT'
+  | 'KITTEN'
+  | 'GOOGLE'
+
+export const speakAndWait = (words: PrimitiveSource<HikkakuString>) => {
+  return block('text2speech_speakAndWait', {
+    inputs: {
+      WORDS: fromPrimitiveSource(InputType.String, words, 'hello'),
+    },
+  })
+}
+
+export const setVoice = (voice: PrimitiveSource<HikkakuString>) => {
+  return block('text2speech_setVoice', {
+    inputs: {
+      VOICE: fromPrimitiveSource(InputType.String, voice, 'ALTO'),
+    },
+  })
+}
+
+export const setLanguage = (language: PrimitiveSource<HikkakuString>) => {
+  return block('text2speech_setLanguage', {
+    inputs: {
+      LANGUAGE: fromPrimitiveSource(InputType.String, language, 'en'),
+    },
+  })
+}

packages/hikkaku/src/blocks/translate.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, test } from 'vite-plus/test'
+import { block, createBlocks } from '../core/composer'
+import { say } from './looks'
+import { getViewerLanguage, translate } from './translate'
+
+describe('blocks/translate', () => {
+  test('creates translate extension blocks', () => {
+    const blocks = createBlocks(() => {
+      block('event_whenflagclicked', { topLevel: true })
+      say(translate('hello', 'ja'))
+      say(getViewerLanguage())
+    })
+
+    const opcodes = Object.values(blocks).map((b) => b.opcode)
+    expect(opcodes).toContain('translate_getTranslate')
+    expect(opcodes).toContain('translate_getViewerLanguage')
+  })
+})

packages/hikkaku/src/blocks/translate.ts

@@ -0,0 +1,20 @@
+import { InputType } from 'sb3-types/enum'
+import { fromPrimitiveSource } from '../core/block-helper'
+import { valueBlock } from '../core/composer'
+import type { HikkakuString, PrimitiveSource } from '../core/types'
+
+export const translate = (
+  words: PrimitiveSource<HikkakuString>,
+  language: PrimitiveSource<HikkakuString>,
+) => {
+  return valueBlock<HikkakuString>('translate_getTranslate', {
+    inputs: {
+      WORDS: fromPrimitiveSource(InputType.String, words, 'hello'),
+      LANGUAGE: fromPrimitiveSource(InputType.String, language, 'ja'),
+    },
+  })
+}
+
+export const getViewerLanguage = () => {
+  return valueBlock<HikkakuString>('translate_getViewerLanguage', {})
+}

packages/hikkaku/src/blocks/videosensing.test.ts

@@ -0,0 +1,27 @@
+import { describe, expect, test } from 'vite-plus/test'
+import { block, createBlocks } from '../core/composer'
+import { say } from './looks'
+import {
+  setVideoTransparency,
+  videoOn,
+  videoToggle,
+  whenMotionGreaterThan,
+} from './videosensing'
+
+describe('blocks/videosensing', () => {
+  test('creates video sensing extension blocks', () => {
+    const blocks = createBlocks(() => {
+      block('event_whenflagclicked', { topLevel: true })
+      whenMotionGreaterThan(10)
+      say(videoOn('motion', 'this sprite'))
+      videoToggle('on')
+      setVideoTransparency(50)
+    })
+
+    const opcodes = Object.values(blocks).map((b) => b.opcode)
+    expect(opcodes).toContain('videoSensing_whenMotionGreaterThan')
+    expect(opcodes).toContain('videoSensing_videoOn')
+    expect(opcodes).toContain('videoSensing_videoToggle')
+    expect(opcodes).toContain('videoSensing_setVideoTransparency')
+  })
+})

packages/hikkaku/src/blocks/videosensing.ts

@@ -0,0 +1,52 @@
+import { InputType } from 'sb3-types/enum'
+import { fromPrimitiveSource } from '../core/block-helper'
+import { block, valueBlock } from '../core/composer'
+import type {
+  HikkakuNumber,
+  HikkakuString,
+  PrimitiveSource,
+} from '../core/types'
+
+export type VideoSensingAttribute = 'motion' | 'direction'
+export type VideoSensingSubject = 'this sprite' | 'stage'
+export type VideoState = 'on' | 'off' | 'on-flipped'
+
+export const whenMotionGreaterThan = (
+  reference: PrimitiveSource<HikkakuNumber>,
+) => {
+  return block('videoSensing_whenMotionGreaterThan', {
+    inputs: {
+      REFERENCE: fromPrimitiveSource(InputType.Number, reference, 10),
+    },
+  })
+}
+
+export const videoOn = (
+  attribute: PrimitiveSource<HikkakuString>,
+  subject: PrimitiveSource<HikkakuString>,
+) => {
+  return valueBlock<HikkakuNumber>('videoSensing_videoOn', {
+    inputs: {
+      ATTRIBUTE: fromPrimitiveSource(InputType.String, attribute, 'motion'),
+      SUBJECT: fromPrimitiveSource(InputType.String, subject, 'this sprite'),
+    },
+  })
+}
+
+export const videoToggle = (state: PrimitiveSource<HikkakuString>) => {
+  return block('videoSensing_videoToggle', {
+    inputs: {
+      VIDEO_STATE: fromPrimitiveSource(InputType.String, state, 'on'),
+    },
+  })
+}
+
+export const setVideoTransparency = (
+  transparency: PrimitiveSource<HikkakuNumber>,
+) => {
+  return block('videoSensing_setVideoTransparency', {
+    inputs: {
+      TRANSPARENCY: fromPrimitiveSource(InputType.Number, transparency, 50),
+    },
+  })
+}