moonscratch 0.1.0 → 0.1.2

package/js/vm/json.ts

@@ -1,273 +0,0 @@
-import type { MoonResult } from './internal-types.ts'
-import type { JsonValue, ProjectJson } from './types.ts'
-
-const isRecord = (input: unknown): input is Record<string, unknown> => {
-  return input !== null && typeof input === 'object' && !Array.isArray(input)
-}
-
-const hasAnyKey = (input: Record<string, unknown>): boolean => {
-  for (const _key in input) {
-    return true
-  }
-  return false
-}
-
-const compactCostumes = (input: unknown): unknown[] => {
-  if (!Array.isArray(input)) {
-    return []
-  }
-  const costumes: unknown[] = []
-  for (const raw of input) {
-    if (!isRecord(raw)) {
-      costumes.push({})
-      continue
-    }
-
-    const costume: Record<string, unknown> = {}
-    if (typeof raw.name === 'string') {
-      costume.name = raw.name
-    }
-    if (typeof raw.assetId === 'string' && raw.assetId.length > 0) {
-      costume.assetId = raw.assetId
-    }
-    if (typeof raw.md5ext === 'string' && raw.md5ext.length > 0) {
-      costume.md5ext = raw.md5ext
-    }
-    if (
-      typeof raw.bitmapResolution === 'number' &&
-      Number.isFinite(raw.bitmapResolution) &&
-      raw.bitmapResolution !== 1
-    ) {
-      costume.bitmapResolution = raw.bitmapResolution
-    }
-    if (
-      typeof raw.rotationCenterX === 'number' &&
-      Number.isFinite(raw.rotationCenterX) &&
-      raw.rotationCenterX !== 0
-    ) {
-      costume.rotationCenterX = raw.rotationCenterX
-    }
-    if (
-      typeof raw.rotationCenterY === 'number' &&
-      Number.isFinite(raw.rotationCenterY) &&
-      raw.rotationCenterY !== 0
-    ) {
-      costume.rotationCenterY = raw.rotationCenterY
-    }
-    if (
-      typeof raw.width === 'number' &&
-      Number.isFinite(raw.width) &&
-      raw.width > 0
-    ) {
-      costume.width = raw.width
-    }
-    if (
-      typeof raw.height === 'number' &&
-      Number.isFinite(raw.height) &&
-      raw.height > 0
-    ) {
-      costume.height = raw.height
-    }
-    costumes.push(costume)
-  }
-  return costumes
-}
-
-const compactBlocks = (input: unknown): Record<string, unknown> => {
-  if (!isRecord(input)) {
-    return {}
-  }
-  const blocks: Record<string, unknown> = {}
-  for (const id in input) {
-    const raw = input[id]
-    if (!isRecord(raw)) {
-      continue
-    }
-
-    const block: Record<string, unknown> = {}
-    if (typeof raw.opcode === 'string') {
-      block.opcode = raw.opcode
-    }
-    if (typeof raw.next === 'string') {
-      block.next = raw.next
-    }
-    if (typeof raw.parent === 'string') {
-      block.parent = raw.parent
-    }
-    if (isRecord(raw.inputs) && hasAnyKey(raw.inputs)) {
-      block.inputs = raw.inputs
-    }
-    if (isRecord(raw.fields) && hasAnyKey(raw.fields)) {
-      block.fields = raw.fields
-    }
-    if (isRecord(raw.mutation) && hasAnyKey(raw.mutation)) {
-      block.mutation = raw.mutation
-    }
-    if (raw.topLevel === true) {
-      block.topLevel = true
-    }
-    blocks[id] = block
-  }
-  return blocks
-}
-
-const compactTargets = (input: unknown): unknown[] => {
-  if (!Array.isArray(input)) {
-    return []
-  }
-  const targets: unknown[] = []
-  for (const raw of input) {
-    if (!isRecord(raw)) {
-      continue
-    }
-
-    const target: Record<string, unknown> = {}
-    if (typeof raw.name === 'string') {
-      target.name = raw.name
-    }
-    if (raw.isStage === true) {
-      target.isStage = true
-    }
-    if (typeof raw.x === 'number' && Number.isFinite(raw.x) && raw.x !== 0) {
-      target.x = raw.x
-    }
-    if (typeof raw.y === 'number' && Number.isFinite(raw.y) && raw.y !== 0) {
-      target.y = raw.y
-    }
-    if (
-      typeof raw.direction === 'number' &&
-      Number.isFinite(raw.direction) &&
-      raw.direction !== 90
-    ) {
-      target.direction = raw.direction
-    }
-    if (
-      typeof raw.size === 'number' &&
-      Number.isFinite(raw.size) &&
-      raw.size !== 100
-    ) {
-      target.size = raw.size
-    }
-    if (
-      typeof raw.volume === 'number' &&
-      Number.isFinite(raw.volume) &&
-      raw.volume !== 100
-    ) {
-      target.volume = raw.volume
-    }
-    if (
-      typeof raw.musicInstrument === 'number' &&
-      Number.isFinite(raw.musicInstrument) &&
-      raw.musicInstrument !== 1
-    ) {
-      target.musicInstrument = raw.musicInstrument
-    }
-    if (
-      typeof raw.textToSpeechVoice === 'string' &&
-      raw.textToSpeechVoice.length > 0 &&
-      raw.textToSpeechVoice !== 'ALTO'
-    ) {
-      target.textToSpeechVoice = raw.textToSpeechVoice
-    }
-    if (raw.visible === false) {
-      target.visible = false
-    }
-    if (
-      typeof raw.currentCostume === 'number' &&
-      Number.isFinite(raw.currentCostume) &&
-      raw.currentCostume !== 0
-    ) {
-      target.currentCostume = raw.currentCostume
-    }
-    target.variables = isRecord(raw.variables) ? raw.variables : {}
-    target.lists = isRecord(raw.lists) ? raw.lists : {}
-    target.blocks = compactBlocks(raw.blocks)
-    target.costumes = compactCostumes(raw.costumes)
-    targets.push(target)
-  }
-  return targets
-}
-
-export const toProjectJsonString = (input: string | ProjectJson): string => {
-  if (typeof input === 'string') {
-    if (input.trim().length === 0) {
-      throw new Error('projectJson must be a non-empty JSON string or object')
-    }
-    return input
-  }
-
-  try {
-    if (!isRecord(input) || !Array.isArray(input.targets)) {
-      return JSON.stringify(input)
-    }
-    return JSON.stringify({
-      targets: compactTargets(input.targets),
-    })
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    throw new Error(`projectJson could not be serialized as JSON: ${message}`)
-  }
-}
-
-export const toJsonString = (
-  input: string | ProjectJson,
-  inputName: string,
-  requireNonEmpty: boolean,
-): string => {
-  if (typeof input === 'string') {
-    if (requireNonEmpty && input.trim().length === 0) {
-      throw new Error(`${inputName} must be a non-empty JSON string or object`)
-    }
-    return input
-  }
-
-  try {
-    return JSON.stringify(input)
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    throw new Error(`${inputName} could not be serialized as JSON: ${message}`)
-  }
-}
-
-export const toOptionalJsonString = (
-  input: string | JsonValue | undefined,
-  inputName: string,
-): string | undefined => {
-  if (input === undefined) {
-    return undefined
-  }
-  return toJsonString(input, inputName, false)
-}
-
-const formatVmError = (error: unknown): string => {
-  if (error && typeof error === 'object') {
-    const candidate = (error as { _0?: unknown })._0
-    if (typeof candidate === 'string' && candidate.trim().length > 0) {
-      return candidate
-    }
-  }
-  try {
-    return JSON.stringify(error)
-  } catch {
-    return String(error)
-  }
-}
-
-export const unwrapResult = <T>(
-  result: MoonResult<T, unknown>,
-  context: string,
-): T => {
-  if (result.$tag === 1) {
-    return result._0
-  }
-  throw new Error(`${context}: ${formatVmError(result._0)}`)
-}
-
-export const parseJson = <T>(text: string, context: string): T => {
-  try {
-    return JSON.parse(text) as T
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    throw new Error(`${context}: failed to parse JSON (${message})`)
-  }
-}

package/js/vm/normalize.test.ts

@@ -1,48 +0,0 @@
-import { describe, expect, test } from 'vite-plus/test'
-
-import {
-  cloneTranslateCache,
-  normalizeLanguage,
-  normalizeMaxFrames,
-  normalizeNowMs,
-  toFrameReport,
-} from './normalize.ts'
-
-describe('moonscratch/js/vm/normalize.ts', () => {
-  test('normalizes language code', () => {
-    expect(normalizeLanguage(' JA ')).toBe('ja')
-    expect(normalizeLanguage('')).toBe('en')
-  })
-
-  test('clones and normalizes translate cache', () => {
-    const cache = cloneTranslateCache({ JA: { hello: 'こんにちは' } })
-    expect(cache).toEqual({ ja: { hello: 'こんにちは' } })
-  })
-
-  test('normalizes frame inputs', () => {
-    expect(normalizeNowMs(16.9)).toBe(16)
-    expect(normalizeMaxFrames(10.7)).toBe(10)
-  })
-
-  test('maps raw frame report fields', () => {
-    expect(
-      toFrameReport({
-        active_threads: 2,
-        tick_count: 4,
-        op_count: 100,
-        emitted_effects: 3,
-        stop_reason: 'timeout',
-        should_render: true,
-        is_in_warp: false,
-      }),
-    ).toEqual({
-      activeThreads: 2,
-      ticks: 4,
-      ops: 100,
-      emittedEffects: 3,
-      stopReason: 'timeout',
-      shouldRender: true,
-      isInWarp: false,
-    })
-  })
-})

package/js/vm/normalize.ts

@@ -1,65 +0,0 @@
-import { DEFAULT_LANGUAGE } from './constants.ts'
-import type { RawFrameReport } from './internal-types.ts'
-import type { FrameReport, FrameStopReason, TranslateCache } from './types.ts'
-
-export const normalizeLanguage = (language: unknown): string =>
-  String(language ?? '')
-    .trim()
-    .toLowerCase() || DEFAULT_LANGUAGE
-
-export const cloneTranslateCache = (
-  cache: TranslateCache | undefined,
-): TranslateCache => {
-  const out: TranslateCache = {}
-  for (const [language, bucket] of Object.entries(cache ?? {})) {
-    if (!bucket || typeof bucket !== 'object' || Array.isArray(bucket)) {
-      continue
-    }
-    const normalizedLanguage = normalizeLanguage(language)
-    out[normalizedLanguage] = {}
-    for (const [words, translated] of Object.entries(bucket)) {
-      out[normalizedLanguage][String(words)] = String(translated)
-    }
-  }
-  return out
-}
-
-export const normalizeNowMs = (nowMs: number): number => {
-  if (!Number.isFinite(nowMs)) {
-    throw new Error('nowMs must be a finite number')
-  }
-  return Math.trunc(nowMs)
-}
-
-export const normalizeMaxFrames = (maxFrames: number): number => {
-  if (!Number.isFinite(maxFrames)) {
-    throw new Error('maxFrames must be a finite number')
-  }
-  const out = Math.trunc(maxFrames)
-  if (out <= 0) {
-    throw new Error('maxFrames must be greater than 0')
-  }
-  return out
-}
-
-const toFrameStopReason = (reason: string): FrameStopReason => {
-  if (
-    reason === 'finished' ||
-    reason === 'timeout' ||
-    reason === 'rerender' ||
-    reason === 'warp-exit'
-  ) {
-    return reason
-  }
-  return 'timeout'
-}
-
-export const toFrameReport = (report: RawFrameReport): FrameReport => ({
-  activeThreads: report.active_threads,
-  ticks: report.tick_count,
-  ops: report.op_count,
-  emittedEffects: report.emitted_effects,
-  stopReason: toFrameStopReason(report.stop_reason),
-  shouldRender: report.should_render,
-  isInWarp: report.is_in_warp,
-})

package/js/vm/options.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, test } from 'vite-plus/test'
-
-import { toOptionsJson } from './options.ts'
-
-describe('moonscratch/js/vm/options.ts', () => {
-  test('returns undefined when options are omitted', () => {
-    expect(toOptionsJson(undefined)).toBeUndefined()
-  })
-
-  test('passes through raw options JSON strings', () => {
-    expect(toOptionsJson('{"turbo":true}')).toBe('{"turbo":true}')
-  })
-
-  test('maps camelCase and snake_case fields to raw options', () => {
-    const json = toOptionsJson({
-      turbo: true,
-      compatibility30tps: true,
-      max_clones: 123,
-      deterministic: true,
-      seed: 42,
-      penWidth: 480,
-      pen_height: 360,
-      stepTimeoutTicks: 2048,
-    })
-
-    expect(json).toBe(
-      '{"turbo":true,"compatibility_30tps":true,"max_clones":123,"deterministic":true,"seed":42,"pen_width":480,"pen_height":360,"step_timeout_ticks":2048}',
-    )
-  })
-})

package/js/vm/options.ts

@@ -1,55 +0,0 @@
-import type { RawVMOptions } from './internal-types.ts'
-import type { VMOptionsInput } from './types.ts'
-
-export const toOptionsJson = (
-  options: string | VMOptionsInput | undefined,
-): string | undefined => {
-  if (options === undefined) {
-    return undefined
-  }
-  if (typeof options === 'string') {
-    return options
-  }
-
-  const raw: RawVMOptions = {}
-  if (options.turbo !== undefined) {
-    raw.turbo = options.turbo
-  }
-
-  const compatibility30tps =
-    options.compatibility30tps ?? options.compatibility_30tps
-  if (compatibility30tps !== undefined) {
-    raw.compatibility_30tps = compatibility30tps
-  }
-
-  const maxClones = options.maxClones ?? options.max_clones
-  if (maxClones !== undefined) {
-    raw.max_clones = maxClones
-  }
-
-  if (options.deterministic !== undefined) {
-    raw.deterministic = options.deterministic
-  }
-
-  if (options.seed !== undefined) {
-    raw.seed = options.seed
-  }
-
-  const penWidth = options.penWidth ?? options.pen_width
-  if (penWidth !== undefined) {
-    raw.pen_width = penWidth
-  }
-
-  const penHeight = options.penHeight ?? options.pen_height
-  if (penHeight !== undefined) {
-    raw.pen_height = penHeight
-  }
-
-  const stepTimeoutTicks =
-    options.stepTimeoutTicks ?? options.step_timeout_ticks
-  if (stepTimeoutTicks !== undefined) {
-    raw.step_timeout_ticks = stepTimeoutTicks
-  }
-
-  return JSON.stringify(raw)
-}

package/js/vm/pen-transparency.test.ts

@@ -1,115 +0,0 @@
-import { Project } from 'hikkaku'
-import {
-  clear,
-  gotoXY,
-  penDown,
-  penUp,
-  setPenColorParamTo,
-  setPenColorToColor,
-  setPenSizeTo,
-  whenFlagClicked,
-} from 'hikkaku/blocks'
-import { describe, expect, test } from 'vite-plus/test'
-import { stepMany } from '../test/test-projects.ts'
-import { createHeadlessVM, createProgramModuleFromProject } from './factory.ts'
-
-describe('moonscratch/js/vm pen transparency', () => {
-  test('does not overdraw alpha by repeatedly blending the same stroke area', () => {
-    const project = new Project()
-    const sprite = project.createSprite('pen-sprite')
-
-    sprite.run(() => {
-      whenFlagClicked(() => {
-        clear()
-        setPenSizeTo(6)
-
-        setPenColorToColor('#ff0000')
-        setPenColorParamTo('transparency', 0)
-        penDown()
-        gotoXY(-100, 0)
-        gotoXY(100, 0)
-        penUp()
-
-        setPenColorToColor('#0000ff')
-        setPenColorParamTo('transparency', 70)
-        penDown()
-        gotoXY(-100, 0)
-        gotoXY(100, 0)
-        penUp()
-      })
-    })
-
-    const program = createProgramModuleFromProject({
-      projectJson: project.toScratch(),
-    })
-    const vm = createHeadlessVM({
-      program,
-      initialNowMs: 0,
-    })
-    vm.greenFlag()
-    stepMany(vm, 8)
-
-    const frame = vm.renderFrame()
-    const centerX = Math.floor(frame.width / 2)
-    const centerY = Math.floor(frame.height / 2)
-    const base = (centerY * frame.width + centerX) * 4
-    const r = frame.pixels[base] ?? 0
-    const g = frame.pixels[base + 1] ?? 0
-    const b = frame.pixels[base + 2] ?? 0
-    const a = frame.pixels[base + 3] ?? 0
-
-    // Blue over red with transparency should stay mixed, not collapse to near-solid blue.
-    expect(a).toBe(255)
-    expect(g).toBeLessThan(16)
-    expect(r).toBeGreaterThan(70)
-    expect(b).toBeGreaterThan(70)
-    expect(r).toBeLessThan(220)
-    expect(b).toBeLessThan(220)
-    expect(Math.abs(r - b)).toBeLessThan(90)
-  })
-
-  test('keeps subpixel coverage on diagonal size-1 pen lines', () => {
-    const project = new Project()
-    const sprite = project.createSprite('pen-sprite')
-
-    sprite.run(() => {
-      whenFlagClicked(() => {
-        clear()
-        setPenSizeTo(1)
-        setPenColorToColor('#00ff00')
-        setPenColorParamTo('transparency', 0)
-        penDown()
-        gotoXY(-120, -80)
-        gotoXY(120, 80)
-        penUp()
-      })
-    })
-
-    const program = createProgramModuleFromProject({
-      projectJson: project.toScratch(),
-    })
-    const vm = createHeadlessVM({
-      program,
-      initialNowMs: 0,
-    })
-    vm.greenFlag()
-    stepMany(vm, 8)
-
-    const frame = vm.renderFrame()
-    let pureGreen = 0
-    let blendedGreen = 0
-    for (let index = 0; index < frame.pixels.length; index += 4) {
-      const r = frame.pixels[index] ?? 0
-      const g = frame.pixels[index + 1] ?? 0
-      const b = frame.pixels[index + 2] ?? 0
-      if (r === 0 && g === 255 && b === 0) {
-        pureGreen += 1
-      } else if (g === 255 && r === b && r > 0 && r < 255) {
-        blendedGreen += 1
-      }
-    }
-
-    expect(pureGreen).toBeGreaterThan(0)
-    expect(blendedGreen).toBeGreaterThan(0)
-  })
-})