evomeme 0.1.9 → 0.1.10

package/dist/canvas-public/features/generation/direction.js

@@ -0,0 +1,163 @@
+import {
+  generationNode,
+  promptField,
+  modelField,
+  refsField,
+  booleanField,
+  colorField,
+  transparentField,
+  clearUnsupportedTransparency,
+  imageWait,
+} from './fields.js'
+
+const fourViewTitle = 'features.generation.generationDialog.text004'
+const eightDirectionTitle = 'features.generation.generationDialog.text005'
+
+function characterReferenceField() {
+  return refsField({
+    path: 'characterRef',
+    default: null,
+    multiple: false,
+    required: true,
+    label: 'features.generation.directionGeneration.text012',
+  })
+}
+
+function sharedFields() {
+  return [
+    promptField({ placeholder: 'features.generation.directionGeneration.text014' }),
+    modelField({ default: 'asset-max' }),
+    transparentField(),
+    colorField('backgroundColor', { visible: (p) => !p.transparentBackground }),
+  ]
+}
+
+function renderSharedFields(ui, references, trailing = null) {
+  return ui.stack(
+    references,
+    ui.prompt('prompt'),
+    ui.row(ui.field('model'), ui.field('backgroundColor')),
+    ui.field('transparentBackground'),
+    trailing,
+  )
+}
+
+const migratePrompt = (saved) => ({
+  ...saved,
+  prompt: saved.prompt ?? saved.characterDescription ?? '',
+})
+
+const sharedBody = (p) => ({
+  character_reference_id: p.characterRef.id,
+  prompt: p.prompt.trim(),
+  background_color: p.backgroundColor,
+  transparent_background: p.model === 'asset-max' && p.transparentBackground,
+  model: p.model,
+})
+
+export const fourView = {
+  render: (ui) => renderSharedFields(ui, ui.field('characterRef')),
+  menu: [{ group: 'character-views', accepts: ['image'] }],
+  toolbar: [
+    {
+      id: 'tool-four-view',
+      group: 'image',
+      label: 'html.text038',
+      title: 'html.text008',
+    },
+  ],
+  id: 'four-view',
+  title: fourViewTitle,
+  node: generationNode('feature_dialog', 420, { minWidth: 300, minHeight: 250 }),
+  storage: 'fourView',
+  sourceField: 'characterRef',
+  fields: [characterReferenceField(), ...sharedFields()],
+  migrate: migratePrompt,
+  changed: clearUnsupportedTransparency,
+  dependencies: (_item, p) => [p.characterRef?.id].filter(Boolean),
+  task(p, services) {
+    return {
+      endpoint: '/api/generate-four-view',
+      options: { allowExternalSync: true },
+      wait: imageWait(
+        p,
+        services,
+        '3024x1296',
+        'features.generation.directionGeneration.text031',
+        [p.characterRef],
+      ),
+      body: sharedBody(p),
+    }
+  },
+}
+
+function migrateLegacyDirectionItem(item) {
+  if (item?.type !== 'eight_direction_dialog' || !item.eightDirection) return false
+  const { outputMode, ...parameters } = item.eightDirection
+  if (outputMode !== 'four-view') {
+    if (outputMode !== undefined) item.eightDirection = parameters
+    return outputMode !== undefined
+  }
+  item.type = 'feature_dialog'
+  item.featureId = 'four-view'
+  item.fourView = parameters
+  delete item.eightDirection
+  return true
+}
+
+export default {
+  render: (ui) =>
+    renderSharedFields(
+      ui,
+      ui.row(ui.field('characterRef'), ui.field('fourViewRef')),
+      ui.field('autoGenerateFourView'),
+    ),
+  menu: [{ group: 'character-views', accepts: ['image'] }],
+  toolbar: [
+    { id: 'tool-eight-direction', group: 'image', label: 'html.text039', title: 'html.text009' },
+  ],
+  id: 'eight-direction',
+  title: eightDirectionTitle,
+  node: generationNode('eight_direction_dialog', 420, { minWidth: 300, minHeight: 250 }),
+  storage: 'eightDirection',
+  sourceField: 'characterRef',
+  fields: [
+    characterReferenceField(),
+    refsField({
+      path: 'fourViewRef',
+      default: null,
+      multiple: false,
+      label: 'features.generation.directionGeneration.text013',
+    }),
+    ...sharedFields(),
+    booleanField('autoGenerateFourView', 'features.generation.directionGeneration.text019', true, {
+      visible: (p) => !p.fourViewRef,
+    }),
+  ],
+  migrateItem: migrateLegacyDirectionItem,
+  migrate: migratePrompt,
+  changed: clearUnsupportedTransparency,
+  dependencies: (_item, p) => [p.fourViewRef?.id || p.characterRef?.id].filter(Boolean),
+  task(p, services) {
+    const reference = p.fourViewRef
+    const auto = !reference && p.autoGenerateFourView
+    return {
+      endpoint: '/api/generate-eight-direction',
+      options: { allowExternalSync: true },
+      wait: imageWait(
+        p,
+        services,
+        auto ? '3024x1296' : '2048x2048',
+        auto
+          ? 'features.generation.directionGeneration.text031'
+          : 'features.generation.directionGeneration.text032',
+        [reference || p.characterRef],
+      ),
+      body: {
+        ...sharedBody(p),
+        four_view_id: reference?.id,
+        auto_generate_four_view: auto,
+      },
+    }
+  },
+}

package/dist/canvas-public/features/generation/fields.js

@@ -0,0 +1,73 @@
+import { state } from '../../core/state.js'
+import { t } from '../../language/index.js'
+
+export const generationNode = (type, width = 268, extra = {}) => ({
+  type,
+  width,
+  minWidth: 240,
+  minHeight: 180,
+  classNames: ['is-interactive-ui', 'is-gen-dialog'],
+  generationInput: true,
+  ...extra,
+})
+export const promptField = (extra = {}) => ({
+  path: 'prompt',
+  type: 'textarea',
+  default: '',
+  label: 'features.generation.scrollImage.promptLabel',
+  ...extra,
+})
+export const modelField = (extra = {}) => ({
+  path: 'model',
+  type: 'enum',
+  default: () => state.meta?.default_model || 'asset-pro',
+  label: 'features.generation.imageGeneration.text005',
+  options: () =>
+    (state.meta?.models || [{ id: 'asset-pro', label: 'asset-pro' }]).map((model) => ({
+      value: model.id,
+      label: model.label,
+    })),
+  ...extra,
+})
+export const refsField = (extra = {}) => ({
+  path: 'refs',
+  type: 'references',
+  reference: true,
+  multiple: true,
+  default: [],
+  label: 'features.generation.gameUiGeneration.text005',
+  ...extra,
+})
+export const booleanField = (path, label, value = false, extra = {}) => ({
+  path,
+  type: 'boolean',
+  label,
+  default: value,
+  ...extra,
+})
+export const colorField = (path = 'backgroundColor', extra = {}) => ({
+  path,
+  type: 'color',
+  label: 'features.generation.scrollImage.backgroundColor',
+  default: '#ff00ff',
+  ...extra,
+})
+export const transparentField = (extra = {}) =>
+  booleanField(
+    'transparentBackground',
+    'features.generation.scrollImage.transparentBackground',
+    false,
+    { visible: (params) => params.model === 'asset-max', ...extra },
+  )
+export const clearUnsupportedTransparency = (params) => {
+  if (params.model !== 'asset-max') params.transparentBackground = false
+}
+export const imageWait = (params, services, size, name, references = params.refs || []) => ({
+  ...services.pendingDisplaySize(size),
+  size,
+  name: t(name),
+  prompt: String(params.prompt || '').trim(),
+  model: params.model,
+  media: 'image',
+  references,
+})

package/dist/canvas-public/features/generation/game-ui.js

@@ -0,0 +1,64 @@
+import { state } from '../../core/state.js'
+import { t } from '../../language/index.js'
+import {
+  generationNode,
+  promptField,
+  modelField,
+  refsField,
+  booleanField,
+  colorField,
+  transparentField,
+  clearUnsupportedTransparency,
+  imageWait,
+} from './fields.js'
+export default {
+  render: (ui) =>
+    ui.stack(
+      ui.prompt('prompt', 'refs'),
+      ui.row(ui.field('model'), ui.field('size')),
+      ui.field('transparentBackground'),
+      ui.field('backgroundColor'),
+      ui.field('autoSplit'),
+    ),
+  toolbar: [
+    { id: 'tool-game-ui-gen', group: 'image', label: 'html.text037', title: 'html.text007' },
+  ],
+  id: 'game-ui',
+  title: 'features.generation.generationDialog.text003',
+  node: generationNode('game_ui_dialog', 420, { minWidth: 320, minHeight: 300 }),
+  storage: 'gameUi',
+  submitLabel: 'features.generation.gameUiGeneration.text018',
+  fields: [
+    promptField({ placeholder: 'features.generation.gameUiGeneration.text007' }),
+    refsField(),
+    modelField({ default: 'asset-max' }),
+    {
+      path: 'size',
+      type: 'enum',
+      default: '1664x2496',
+      label: 'features.generation.gameUiGeneration.text009',
+      options: () => state.meta?.size_presets || ['1664x2496'],
+    },
+    transparentField(),
+    colorField('backgroundColor', { visible: (p) => !p.transparentBackground }),
+    booleanField('autoSplit', 'features.generation.gameUiGeneration.text013', true),
+  ],
+  changed: clearUnsupportedTransparency,
+  validate: (p) => (p.refs.length > 14 ? t('features.generation.gameUiGeneration.text002') : ''),
+  task(p, services) {
+    return {
+      endpoint: '/api/generate-game-ui-components',
+      options: { allowExternalSync: true },
+      wait: imageWait(p, services, p.size, 'features.generation.gameUiGeneration.text019'),
+      body: {
+        prompt: p.prompt.trim(),
+        background_color: p.backgroundColor,
+        transparent_background: p.model === 'asset-max' && p.transparentBackground,
+        auto_split: p.autoSplit,
+        model: p.model,
+        size: p.size,
+        reference_ids: p.refs.map((r) => r.id),
+      },
+    }
+  },
+}

package/dist/canvas-public/features/generation/image.js

@@ -0,0 +1,83 @@
+import { state } from '../../core/state.js'
+import { t } from '../../language/index.js'
+import { generationNode, promptField, modelField, refsField, imageWait } from './fields.js'
+
+export default {
+  render: (ui) =>
+    ui.stack(
+      ui.prompt('prompt', 'refs'),
+      ui.row(ui.field('model'), ui.field('background')),
+      ui.row(ui.field('sizeMode'), ui.field('sizePreset'), ui.field('sizeCustom')),
+    ),
+  toolbar: [{ id: 'tool-image-gen', group: 'image', label: 'html.text033', title: 'html.text006' }],
+  id: 'image',
+  title: 'features.generation.generationDialog.text009',
+  node: generationNode('gen_dialog', 420),
+  storage: 'imageGeneration',
+  fields: [
+    promptField({ required: true, placeholder: 'features.generation.imageGeneration.text022' }),
+    refsField(),
+    modelField(),
+    {
+      path: 'background',
+      type: 'enum',
+      default: 'auto',
+      label: 'inspector.uiInspector.text014',
+      visible: (p) => p.model !== 'asset-lite',
+      options: () =>
+        ['auto', 'transparent', 'opaque'].map((value, index) => ({
+          value,
+          labelKey: `features.generation.generationControls.text00${index + 1}`,
+        })),
+    },
+    {
+      path: 'sizeMode',
+      type: 'enum',
+      default: 'preset',
+      label: 'inspector.uiInspector.text016',
+      options: [
+        { value: 'preset', labelKey: 'inspector.uiInspector.text018' },
+        { value: 'custom', labelKey: 'inspector.uiInspector.text019' },
+      ],
+    },
+    {
+      path: 'sizePreset',
+      type: 'enum',
+      default: () => state.meta?.default_size || '1024x1024',
+      label: 'inspector.uiInspector.text018',
+      options: () => state.meta?.size_presets || ['1024x1024'],
+      visible: (p) => p.sizeMode !== 'custom',
+    },
+    {
+      path: 'sizeCustom',
+      type: 'text',
+      default: '1920x1080',
+      label: 'inspector.uiInspector.text019',
+      visible: (p) => p.sizeMode === 'custom',
+    },
+  ],
+  validate(p) {
+    if (
+      p.model === 'asset-pro' &&
+      p.background === 'transparent' &&
+      !(p.refs.length === 1 && /\.png(?:$|[?#])/i.test(p.refs[0].id || p.refs[0].name))
+    )
+      return t('app.text001')
+    return ''
+  },
+  task(p, services) {
+    const size = p.sizeMode === 'custom' ? p.sizeCustom.trim() : p.sizePreset
+    return {
+      endpoint: '/api/generate',
+      wait: imageWait(p, services, size, 'features.generation.imageGeneration.text026'),
+      body: {
+        prompt: p.prompt.trim(),
+        size,
+        model: p.model,
+        reference_ids: p.refs.map((r) => r.id),
+        ...(p.model !== 'asset-lite' ? { background: p.background } : {}),
+        place: false,
+      },
+    }
+  },
+}

package/dist/canvas-public/features/generation/scroll-image.js

@@ -0,0 +1,157 @@
+import { t } from '../../language/index.js'
+import {
+  generationNode,
+  promptField,
+  modelField,
+  refsField,
+  booleanField,
+  colorField,
+  imageWait,
+} from './fields.js'
+import { state } from '../../core/state.js'
+import { applyScrollPreviews } from '../editing/scroll-preview.js'
+
+const key = (name) => `features.generation.scrollImage.${name}`
+const PREVIEW_SPEEDS = { background: 20, midground: 40, foreground: 80 }
+
+function generatedScrollPreviewTargets(result) {
+  if (!result || typeof result !== 'object') return []
+  return Object.entries(PREVIEW_SPEEDS).flatMap(([layer, speed]) => {
+    const output = layer === 'background' ? result.background || result : result[layer]
+    const id = typeof output === 'string' ? output : output?.id
+    return id ? [{ id, speed }] : []
+  })
+}
+
+export function generatedScrollPreviewUpdates(result, items = state.layoutItems) {
+  return generatedScrollPreviewTargets(result).flatMap(({ id, speed }) => {
+    const source = items.find((item) => item.id === id)
+    return source
+      ? [{ source, params: { enabled: true, direction: 'left', speed } }]
+      : []
+  })
+}
+
+async function waitForGeneratedScrollOutputs(result, services) {
+  const expected = generatedScrollPreviewTargets(result).length
+  let updates = generatedScrollPreviewUpdates(result)
+  if (updates.length >= expected || typeof services.reload !== 'function') return updates
+
+  // Progressive task updates can leave a snapshot refresh in flight when the root
+  // request resolves. Wait for it, then request one fresh snapshot containing all layers.
+  for (let attempt = 0; state.refreshing && attempt < 200; attempt += 1) {
+    await new Promise((resolve) => setTimeout(resolve, 25))
+  }
+  await services.reload()
+  updates = generatedScrollPreviewUpdates(result)
+  return updates
+}
+
+function layerFields(layer) {
+  return {
+    label: key(`${layer}Module`),
+    enablePath: `${layer}.enabled`,
+    fields: [
+      { path: `${layer}.enabled`, type: 'hidden', default: false },
+      promptField({
+        path: `${layer}.prompt`,
+        required: true,
+        placeholder: key(`${layer}PromptPlaceholder`),
+      }),
+      booleanField(`${layer}.transparentBackground`, key('transparentBackground')),
+      colorField(`${layer}.backgroundColor`, { visible: (p) => !p[layer].transparentBackground }),
+      booleanField(`${layer}.seamEliminationEnabled`, key('layerSeamElimination')),
+      { id: layer + 'ReferenceHint', type: 'note', label: key('backgroundReferenceHint') },
+    ],
+  }
+}
+
+export default {
+  styles:
+    '[data-feature-form="scroll-image"][data-surface="canvas"] .feature-form-content { max-height: 600px; }',
+  render(ui, { inspector }) {
+    const layer = (name) =>
+      ui.section(
+        name + '.enabled',
+        ui.prompt(name + '.prompt'),
+        ui.field(name + '.transparentBackground'),
+        ui.field(name + '.backgroundColor'),
+        ui.field(name + '.seamEliminationEnabled'),
+        ui.field(name + 'ReferenceHint'),
+      )
+    const layers = inspector
+      ? ui.stack(layer('midground'), layer('foreground'))
+      : ui.row(layer('midground'), layer('foreground'))
+    layers.style.setProperty('--field-min', '300px')
+    return ui.stack(
+      ui.section(
+        'background',
+        ui.prompt('prompt', 'refs'),
+        ui.row(ui.field('model'), ui.field('seamEliminationEnabled')),
+      ),
+      layers,
+    )
+  },
+  toolbar: [
+    {
+      id: 'tool-scroll-image-gen',
+      group: 'image',
+      label: 'features.generation.scrollImage.toolbar',
+      title: 'features.generation.scrollImage.toolbarTitle',
+    },
+  ],
+  id: 'scroll-image',
+  title: key('title'),
+  node: generationNode('scroll_image_dialog', 820, { minWidth: 380 }),
+  storage: 'scrollImage',
+  fields: [
+    {
+      id: 'background',
+      label: key('backgroundModule'),
+      fields: [
+        promptField({ required: true, placeholder: key('promptPlaceholder') }),
+        refsField(),
+        modelField(),
+        booleanField('seamEliminationEnabled', key('seamElimination')),
+      ],
+    },
+    layerFields('midground'),
+    layerFields('foreground'),
+  ],
+  validate(p) {
+    if (
+      p.model !== 'asset-max' &&
+      ['midground', 'foreground'].some((layer) => p[layer].enabled && p[layer].transparentBackground)
+    )
+      return t(key('transparentModelRequired'))
+    return ''
+  },
+  task(p, services) {
+    const body = {
+      prompt: p.prompt.trim(),
+      model: p.model,
+      seam_elimination_enabled: p.seamEliminationEnabled,
+      ...(p.refs.length ? { reference_ids: p.refs.map((ref) => ref.id) } : {}),
+    }
+    for (const layer of ['midground', 'foreground']) {
+      body[`${layer}_enabled`] = p[layer].enabled
+      body[`${layer}_prompt`] = p[layer].prompt.trim()
+      body[`${layer}_background_color`] = p[layer].backgroundColor
+      body[`${layer}_transparent_background`] =
+        p[layer].enabled && p[layer].transparentBackground
+      body[`${layer}_seam_elimination_enabled`] = p[layer].seamEliminationEnabled
+    }
+    return {
+      endpoint: '/api/generate-scroll-image',
+      options: { allowExternalSync: true },
+      body,
+      wait: imageWait(p, services, '3024x1296', key('generating')),
+    }
+  },
+  async afterTaskSuccess({ result }, services) {
+    const updates = await waitForGeneratedScrollOutputs(result, services)
+    if (!updates.length) return
+    await applyScrollPreviews(updates, services)
+    services.renderChrome()
+  },
+}

package/dist/canvas-public/features/generation/seamless-tile.js

@@ -0,0 +1,52 @@
+import {
+  generationNode,
+  promptField,
+  modelField,
+  refsField,
+  booleanField,
+  imageWait,
+} from './fields.js'
+
+export default {
+  render: (ui) =>
+    ui.stack(
+      ui.prompt('prompt', 'refs'),
+      ui.row(ui.field('model'), ui.field('sizePreset')),
+      ui.field('seamEliminationEnabled'),
+    ),
+  toolbar: [
+    { id: 'tool-seamless-tile-gen', group: 'image', label: 'html.text040', title: 'html.text010' },
+  ],
+  id: 'seamless-tile',
+  title: 'features.generation.generationDialog.text007',
+  node: generationNode('seamless_tile_dialog', 400),
+  storage: 'seamlessTile',
+  fields: [
+    promptField({ required: true, placeholder: 'features.generation.imageGeneration.text004' }),
+    refsField(),
+    modelField(),
+    {
+      path: 'sizePreset',
+      storagePath: 'size',
+      type: 'enum',
+      default: '1024x1024',
+      options: ['1024x1024', '2048x2048'],
+      label: 'features.generation.imageGeneration.text006',
+    },
+    booleanField('seamEliminationEnabled', 'features.generation.imageGeneration.text007'),
+  ],
+  task(p, services) {
+    return {
+      endpoint: '/api/generate-seamless-tile',
+      options: { allowExternalSync: true },
+      wait: imageWait(p, services, p.sizePreset, 'features.generation.imageGeneration.text027'),
+      body: {
+        prompt: p.prompt.trim(),
+        size: p.sizePreset,
+        model: p.model,
+        reference_ids: p.refs.map((r) => r.id),
+        seam_elimination_enabled: p.seamEliminationEnabled,
+      },
+    }
+  },
+}

package/dist/canvas-public/features/generation/tile-transition-atlas.js

@@ -0,0 +1,79 @@
+import { t } from '../../language/index.js'
+import { generationNode, promptField, modelField, refsField, imageWait } from './fields.js'
+
+export default {
+  render: (ui) =>
+    ui.stack(
+      ui.field('guide'),
+      ui.row(ui.field('terrainZeroRef'), ui.field('terrainOneRef')),
+      ui.prompt('prompt'),
+      ui.row(ui.field('model'), ui.field('tileSize')),
+    ),
+  menu: [{ group: 'map-tiles', accepts: ['image'] }],
+  toolbar: [
+    {
+      id: 'tool-tile-transition-atlas',
+      group: 'image',
+      label: 'html.text041',
+      title: 'html.text011',
+    },
+  ],
+  id: 'tile-transition-atlas',
+  title: 'features.generation.generationDialog.text008',
+  node: generationNode('tile_transition_atlas_dialog', 420),
+  storage: 'tileTransitionAtlas',
+  sourceField: 'terrainOneRef',
+  fields: [
+    {
+      id: 'guide',
+      type: 'illustration',
+      src: '/tile-transition-mask.svg',
+      label: 'features.generation.imageGeneration.text012',
+    },
+    refsField({
+      path: 'terrainZeroRef',
+      default: null,
+      multiple: false,
+      required: true,
+      label: 'features.generation.imageGeneration.text017',
+    }),
+    refsField({
+      path: 'terrainOneRef',
+      default: null,
+      multiple: false,
+      required: true,
+      label: 'features.generation.imageGeneration.text018',
+    }),
+    promptField({ placeholder: 'features.generation.imageGeneration.text013' }),
+    modelField(),
+    {
+      path: 'tileSize',
+      type: 'enum',
+      valueType: 'number',
+      default: 128,
+      options: [32, 64, 128, 256, 512, 1024, 2048],
+      label: 'features.generation.imageGeneration.text019',
+    },
+  ],
+  validate: (p) =>
+    p.terrainZeroRef?.id && p.terrainZeroRef.id === p.terrainOneRef?.id
+      ? t('features.generation.imageGeneration.text024')
+      : '',
+  task(p, services) {
+    const size = `${p.tileSize * 4}x${p.tileSize * 4}`
+    return {
+      endpoint: '/api/generate-tile-transition-atlas',
+      options: { allowExternalSync: true },
+      wait: imageWait(p, services, size, 'features.generation.imageGeneration.text025', [
+        p.terrainZeroRef,
+        p.terrainOneRef,
+      ]),
+      body: {
+        reference_ids: [p.terrainZeroRef.id, p.terrainOneRef.id],
+        tile_size: p.tileSize,
+        prompt: p.prompt.trim(),
+        model: p.model,
+      },
+    }
+  },
+}