Towsty
a8ae61704e
Sets and beats filter by shot size; scenes reorder/delete; portrait links Prompt Builder; landscape queue collapses; per-engine look settings and prompt Clear persist across iOS resumes.
504 lines
16 KiB
TypeScript
504 lines
16 KiB
TypeScript
export type PromptSequenceOutfit = {
|
|
id: string
|
|
name: string
|
|
description: string
|
|
}
|
|
|
|
export type PromptSequenceCharacter = {
|
|
id: string
|
|
name: string
|
|
description: string
|
|
outfits: PromptSequenceOutfit[]
|
|
}
|
|
|
|
export type PromptSequenceCharacterState = {
|
|
characterId: string
|
|
on: boolean
|
|
/** Active outfit id for this scene, or null/'' for none. */
|
|
outfitId: string | null
|
|
}
|
|
|
|
export type PromptSequenceShotSize = '' | 'wide' | 'medium' | 'close-up' | 'detail'
|
|
|
|
export const PROMPT_SEQUENCE_SHOT_SIZES = ['wide', 'medium', 'close-up', 'detail'] as const
|
|
|
|
export type PromptSequenceBeat = {
|
|
id: string
|
|
name: string
|
|
text: string
|
|
/** Empty = always include for any shot size. */
|
|
framings: Array<'wide' | 'medium' | 'close-up' | 'detail'>
|
|
}
|
|
|
|
export type PromptSequenceSet = {
|
|
id: string
|
|
name: string
|
|
description: string
|
|
beats: PromptSequenceBeat[]
|
|
}
|
|
|
|
export type PromptSequenceSetState = {
|
|
setId: string
|
|
on: boolean
|
|
}
|
|
|
|
export type PromptSequenceScene = {
|
|
id: string
|
|
title: string
|
|
style: string
|
|
settings: string
|
|
shotSize: PromptSequenceShotSize
|
|
setStates: PromptSequenceSetState[]
|
|
characterStates: PromptSequenceCharacterState[]
|
|
prompt: string
|
|
}
|
|
|
|
export type PromptSequence = {
|
|
id: string
|
|
name: string
|
|
characters: PromptSequenceCharacter[]
|
|
sets: PromptSequenceSet[]
|
|
scenes: PromptSequenceScene[]
|
|
createdAt: number
|
|
updatedAt: number
|
|
}
|
|
|
|
export const PROMPT_SEQUENCE_NAME_MAX = 80
|
|
export const PROMPT_SEQUENCE_FIELD_MAX = 50_000
|
|
export const PROMPT_SEQUENCE_TITLE_MAX = 60
|
|
|
|
export function newId() {
|
|
if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
|
|
return crypto.randomUUID()
|
|
}
|
|
return `ps-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`
|
|
}
|
|
|
|
export function emptyOutfit(): PromptSequenceOutfit {
|
|
return { id: newId(), name: '', description: '' }
|
|
}
|
|
|
|
export function emptyCharacter(): PromptSequenceCharacter {
|
|
return { id: newId(), name: '', description: '', outfits: [] }
|
|
}
|
|
|
|
export function emptyBeat(): PromptSequenceBeat {
|
|
return { id: newId(), name: '', text: '', framings: [] }
|
|
}
|
|
|
|
export function emptySet(): PromptSequenceSet {
|
|
return { id: newId(), name: '', description: '', beats: [emptyBeat()] }
|
|
}
|
|
|
|
export function defaultCharacterState(characterId: string, on = true): PromptSequenceCharacterState {
|
|
return { characterId, on, outfitId: null }
|
|
}
|
|
|
|
export function defaultSetState(setId: string, on = true): PromptSequenceSetState {
|
|
return { setId, on }
|
|
}
|
|
|
|
export function emptyScene(
|
|
index = 1,
|
|
characters: PromptSequenceCharacter[] = [],
|
|
sets: PromptSequenceSet[] = []
|
|
): PromptSequenceScene {
|
|
return {
|
|
id: newId(),
|
|
title: `Scene ${Math.max(1, index)}`,
|
|
style: '',
|
|
settings: '',
|
|
shotSize: '',
|
|
setStates: sets.map(set => defaultSetState(set.id, true)),
|
|
characterStates: characters.map(character => defaultCharacterState(character.id, true)),
|
|
prompt: ''
|
|
}
|
|
}
|
|
|
|
export function cloneSceneForNext(previous: PromptSequenceScene, nextIndex: number): PromptSequenceScene {
|
|
return {
|
|
id: newId(),
|
|
title: `Scene ${nextIndex}`,
|
|
style: previous.style,
|
|
settings: previous.settings,
|
|
shotSize: previous.shotSize || '',
|
|
setStates: (previous.setStates || []).map(state => ({
|
|
setId: state.setId,
|
|
on: !!state.on
|
|
})),
|
|
characterStates: (previous.characterStates || []).map(state => ({
|
|
characterId: state.characterId,
|
|
on: !!state.on,
|
|
outfitId: state.outfitId || null
|
|
})),
|
|
prompt: previous.prompt
|
|
}
|
|
}
|
|
|
|
function outfitPromptText(outfit?: { name?: string; description?: string } | null) {
|
|
if (!outfit) return ''
|
|
return String(outfit.description || '').trim() || String(outfit.name || '').trim()
|
|
}
|
|
|
|
/**
|
|
* Character line when on:
|
|
* - with outfit: "Name: description. Outfit: outfit description"
|
|
* - without: "Name: description" (or name-only / description-only)
|
|
*/
|
|
export function formatCharacterLine(
|
|
character: { name?: string; description?: string },
|
|
outfit?: { name?: string; description?: string } | null
|
|
) {
|
|
const name = String(character?.name || '').trim()
|
|
const description = String(character?.description || '').trim()
|
|
let base = ''
|
|
if (name && description) base = `${name}: ${description}`
|
|
else base = name || description
|
|
if (!base) return ''
|
|
const outfitText = outfitPromptText(outfit)
|
|
if (!outfitText) return base
|
|
return `${base}. Outfit: ${outfitText}`
|
|
}
|
|
|
|
export function beatMatchesShotSize(
|
|
beat: { framings?: string[] },
|
|
shotSize: string = ''
|
|
) {
|
|
const framings = Array.isArray(beat.framings) ? beat.framings.filter(Boolean) : []
|
|
if (!framings.length) return true
|
|
if (!shotSize) return true
|
|
return framings.includes(shotSize)
|
|
}
|
|
|
|
/** Set description + matching beat texts (one per line). No set/beat names or framing tags. */
|
|
export function assembleSetBlock(
|
|
scene: { shotSize?: string; setStates?: PromptSequenceSetState[] },
|
|
sets: PromptSequenceSet[] = []
|
|
) {
|
|
const states = scene.setStates || []
|
|
const stateById = new Map(states.map(state => [state.setId, state]))
|
|
const chunks: string[] = []
|
|
for (const set of sets) {
|
|
const state = stateById.get(set.id)
|
|
if (state && !state.on) continue
|
|
const description = String(set.description || '').trim()
|
|
const beatLines = (set.beats || [])
|
|
.filter(beat => beatMatchesShotSize(beat, scene.shotSize || ''))
|
|
.map(beat => String(beat.text || '').trim())
|
|
.filter(Boolean)
|
|
const lines = [description, ...beatLines].filter(Boolean)
|
|
if (lines.length) chunks.push(lines.join('\n'))
|
|
}
|
|
return chunks.join('\n')
|
|
}
|
|
|
|
export function resolveSceneCharacterLines(
|
|
scene: { characterStates?: PromptSequenceCharacterState[] },
|
|
characters: PromptSequenceCharacter[] = []
|
|
) {
|
|
const states = scene.characterStates || []
|
|
const stateById = new Map(states.map(state => [state.characterId, state]))
|
|
return characters
|
|
.map((character) => {
|
|
const state = stateById.get(character.id)
|
|
if (state && !state.on) return ''
|
|
const outfitId = state?.outfitId || null
|
|
const outfit = outfitId
|
|
? (character.outfits || []).find(item => item.id === outfitId) || null
|
|
: null
|
|
return formatCharacterLine(character, outfit)
|
|
})
|
|
.filter(Boolean)
|
|
}
|
|
|
|
export function assembleSceneText(
|
|
scene: {
|
|
style?: string
|
|
settings?: string
|
|
prompt?: string
|
|
shotSize?: string
|
|
setStates?: PromptSequenceSetState[]
|
|
characterStates?: PromptSequenceCharacterState[]
|
|
/** Legacy per-scene characters (migration / old tests). */
|
|
characters?: Array<{ name?: string; description?: string }>
|
|
},
|
|
sequenceCharacters?: PromptSequenceCharacter[],
|
|
sequenceSets?: PromptSequenceSet[]
|
|
) {
|
|
const setBlock = sequenceSets?.length
|
|
? assembleSetBlock(scene, sequenceSets)
|
|
: ''
|
|
const characterBlock = sequenceCharacters?.length
|
|
? resolveSceneCharacterLines(scene, sequenceCharacters).join('\n')
|
|
: (scene.characters || [])
|
|
.map(character => formatCharacterLine(character))
|
|
.filter(Boolean)
|
|
.join('\n')
|
|
const parts = [
|
|
String(scene.style || '').trim(),
|
|
String(scene.settings || '').trim(),
|
|
setBlock,
|
|
characterBlock,
|
|
String(scene.prompt || '').trim()
|
|
].filter(Boolean)
|
|
return parts.join('\n\n')
|
|
}
|
|
|
|
/**
|
|
* Whole sequence as one copyable block.
|
|
* Scenes join with a double blank line (\n\n\n) — same separator desktop Batch uses.
|
|
* Sequence name is never included.
|
|
*/
|
|
export function assembleSequenceText(sequence: {
|
|
characters?: PromptSequenceCharacter[]
|
|
sets?: PromptSequenceSet[]
|
|
scenes?: Array<{
|
|
style?: string
|
|
settings?: string
|
|
prompt?: string
|
|
shotSize?: string
|
|
setStates?: PromptSequenceSetState[]
|
|
characterStates?: PromptSequenceCharacterState[]
|
|
characters?: Array<{ name?: string; description?: string }>
|
|
}>
|
|
}) {
|
|
const characters = sequence.characters || []
|
|
const sets = sequence.sets || []
|
|
return (sequence.scenes || [])
|
|
.map(scene => assembleSceneText(
|
|
scene,
|
|
characters.length ? characters : undefined,
|
|
sets.length ? sets : undefined
|
|
))
|
|
.filter(Boolean)
|
|
.join('\n\n\n')
|
|
}
|
|
|
|
export function normalizePromptSequenceName(raw: unknown) {
|
|
return String(raw || '').trim().replace(/\s+/g, ' ').slice(0, PROMPT_SEQUENCE_NAME_MAX)
|
|
}
|
|
|
|
export function normalizePromptSequenceField(raw: unknown) {
|
|
return String(raw || '').replace(/\r\n/g, '\n').slice(0, PROMPT_SEQUENCE_FIELD_MAX)
|
|
}
|
|
|
|
export function normalizePromptSequenceTitle(raw: unknown, fallback: string) {
|
|
const title = String(raw || '').trim().replace(/\s+/g, ' ').slice(0, PROMPT_SEQUENCE_TITLE_MAX)
|
|
return title || fallback
|
|
}
|
|
|
|
export function normalizeShotSize(raw: unknown): PromptSequenceShotSize {
|
|
const value = String(raw || '').trim()
|
|
if (value === 'wide' || value === 'medium' || value === 'close-up' || value === 'detail') return value
|
|
return ''
|
|
}
|
|
|
|
export function normalizeOutfit(raw: unknown): PromptSequenceOutfit {
|
|
const rec = (raw && typeof raw === 'object' ? raw : {}) as Record<string, unknown>
|
|
return {
|
|
id: String(rec.id || '').trim() || newId(),
|
|
name: String(rec.name || '').trim().slice(0, 120),
|
|
description: normalizePromptSequenceField(rec.description).trim()
|
|
}
|
|
}
|
|
|
|
export function normalizeCharacter(raw: unknown): PromptSequenceCharacter {
|
|
const rec = (raw && typeof raw === 'object' ? raw : {}) as Record<string, unknown>
|
|
const outfits = Array.isArray(rec.outfits) ? rec.outfits.map(normalizeOutfit) : []
|
|
return {
|
|
id: String(rec.id || '').trim() || newId(),
|
|
name: String(rec.name || '').trim().slice(0, 120),
|
|
description: normalizePromptSequenceField(rec.description).trim(),
|
|
outfits
|
|
}
|
|
}
|
|
|
|
export function normalizeBeat(raw: unknown): PromptSequenceBeat {
|
|
const rec = (raw && typeof raw === 'object' ? raw : {}) as Record<string, unknown>
|
|
const framings = Array.isArray(rec.framings)
|
|
? [...new Set(rec.framings.map(item => String(item || '').trim()).filter((item): item is 'wide' | 'medium' | 'close-up' | 'detail' =>
|
|
item === 'wide' || item === 'medium' || item === 'close-up' || item === 'detail'
|
|
))]
|
|
: []
|
|
return {
|
|
id: String(rec.id || '').trim() || newId(),
|
|
name: String(rec.name || '').trim().slice(0, 120),
|
|
text: normalizePromptSequenceField(rec.text),
|
|
framings
|
|
}
|
|
}
|
|
|
|
export function normalizeSet(raw: unknown): PromptSequenceSet {
|
|
const rec = (raw && typeof raw === 'object' ? raw : {}) as Record<string, unknown>
|
|
const beats = Array.isArray(rec.beats) ? rec.beats.map(normalizeBeat) : []
|
|
return {
|
|
id: String(rec.id || '').trim() || newId(),
|
|
name: String(rec.name || '').trim().slice(0, 120),
|
|
description: normalizePromptSequenceField(rec.description),
|
|
beats: beats.length ? beats : [emptyBeat()]
|
|
}
|
|
}
|
|
|
|
export function normalizeCharacterState(raw: unknown, fallbackCharacterId = ''): PromptSequenceCharacterState {
|
|
const rec = (raw && typeof raw === 'object' ? raw : {}) as Record<string, unknown>
|
|
const characterId = String(rec.characterId || fallbackCharacterId || '').trim()
|
|
const outfitRaw = rec.outfitId
|
|
const outfitId = outfitRaw == null || outfitRaw === '' ? null : String(outfitRaw).trim() || null
|
|
return {
|
|
characterId,
|
|
on: rec.on === undefined ? true : !!rec.on,
|
|
outfitId
|
|
}
|
|
}
|
|
|
|
export function normalizeSetState(raw: unknown, fallbackSetId = ''): PromptSequenceSetState {
|
|
const rec = (raw && typeof raw === 'object' ? raw : {}) as Record<string, unknown>
|
|
return {
|
|
setId: String(rec.setId || fallbackSetId || '').trim(),
|
|
on: rec.on === undefined ? true : !!rec.on
|
|
}
|
|
}
|
|
|
|
function liftLegacyCharacters(scenesRaw: unknown[]): PromptSequenceCharacter[] {
|
|
const byId = new Map<string, PromptSequenceCharacter>()
|
|
for (const scene of scenesRaw) {
|
|
if (!scene || typeof scene !== 'object') continue
|
|
const chars = (scene as Record<string, unknown>).characters
|
|
if (!Array.isArray(chars)) continue
|
|
for (const character of chars) {
|
|
const normalized = normalizeCharacter(character)
|
|
if (!byId.has(normalized.id)) byId.set(normalized.id, normalized)
|
|
}
|
|
}
|
|
return [...byId.values()]
|
|
}
|
|
|
|
function syncCharacterStates(
|
|
statesRaw: unknown,
|
|
characters: PromptSequenceCharacter[],
|
|
defaultOn = true
|
|
): PromptSequenceCharacterState[] {
|
|
const incoming = Array.isArray(statesRaw)
|
|
? statesRaw.map(state => normalizeCharacterState(state)).filter(state => state.characterId)
|
|
: []
|
|
const byId = new Map(incoming.map(state => [state.characterId, state]))
|
|
return characters.map((character) => {
|
|
const existing = byId.get(character.id)
|
|
if (existing) {
|
|
const outfitOk = existing.outfitId
|
|
&& character.outfits.some(outfit => outfit.id === existing.outfitId)
|
|
return {
|
|
characterId: character.id,
|
|
on: existing.on,
|
|
outfitId: outfitOk ? existing.outfitId : null
|
|
}
|
|
}
|
|
return defaultCharacterState(character.id, defaultOn)
|
|
})
|
|
}
|
|
|
|
function syncSetStates(
|
|
statesRaw: unknown,
|
|
sets: PromptSequenceSet[],
|
|
defaultOn = true
|
|
): PromptSequenceSetState[] {
|
|
const incoming = Array.isArray(statesRaw)
|
|
? statesRaw.map(state => normalizeSetState(state)).filter(state => state.setId)
|
|
: []
|
|
const byId = new Map(incoming.map(state => [state.setId, state]))
|
|
return sets.map((set) => {
|
|
const existing = byId.get(set.id)
|
|
if (existing) return { setId: set.id, on: existing.on }
|
|
return defaultSetState(set.id, defaultOn)
|
|
})
|
|
}
|
|
|
|
export function normalizeScene(
|
|
raw: unknown,
|
|
index: number,
|
|
characters: PromptSequenceCharacter[] = [],
|
|
sets: PromptSequenceSet[] = []
|
|
): PromptSequenceScene {
|
|
const rec = (raw && typeof raw === 'object' ? raw : {}) as Record<string, unknown>
|
|
return {
|
|
id: String(rec.id || '').trim() || newId(),
|
|
title: normalizePromptSequenceTitle(rec.title, `Scene ${index + 1}`),
|
|
style: normalizePromptSequenceField(rec.style),
|
|
settings: normalizePromptSequenceField(rec.settings),
|
|
shotSize: normalizeShotSize(rec.shotSize),
|
|
setStates: syncSetStates(rec.setStates, sets, true),
|
|
characterStates: syncCharacterStates(rec.characterStates, characters, true),
|
|
prompt: normalizePromptSequenceField(rec.prompt)
|
|
}
|
|
}
|
|
|
|
export function normalizePromptSequence(raw: unknown): PromptSequence | null {
|
|
if (!raw || typeof raw !== 'object') return null
|
|
const rec = raw as Record<string, unknown>
|
|
const name = normalizePromptSequenceName(rec.name)
|
|
if (!name) return null
|
|
const scenesRaw = Array.isArray(rec.scenes) ? rec.scenes : []
|
|
let characters = Array.isArray(rec.characters)
|
|
? rec.characters.map(normalizeCharacter)
|
|
: liftLegacyCharacters(scenesRaw)
|
|
if (!characters.length) characters = [emptyCharacter()]
|
|
const sets = Array.isArray(rec.sets) ? rec.sets.map(normalizeSet) : []
|
|
const scenes = scenesRaw.length
|
|
? scenesRaw.map((scene, index) => normalizeScene(scene, index, characters, sets))
|
|
: [emptyScene(1, characters, sets)]
|
|
const createdAt = Number(rec.createdAt) || Date.now()
|
|
return {
|
|
id: String(rec.id || '').trim() || newId(),
|
|
name,
|
|
characters,
|
|
sets,
|
|
scenes,
|
|
createdAt,
|
|
updatedAt: Number(rec.updatedAt) || createdAt
|
|
}
|
|
}
|
|
|
|
/** Ensure every scene has a state row for every sequence character. */
|
|
export function ensureSceneStatesForCharacters(
|
|
scenes: PromptSequenceScene[],
|
|
characters: PromptSequenceCharacter[],
|
|
opts?: { newCharacterId?: string; turnOnSceneIndex?: number }
|
|
) {
|
|
const newCharacterId = opts?.newCharacterId
|
|
const turnOnIndex = opts?.turnOnSceneIndex
|
|
for (let i = 0; i < scenes.length; i++) {
|
|
const scene = scenes[i]
|
|
const byId = new Map(scene.characterStates.map(state => [state.characterId, state]))
|
|
scene.characterStates = characters.map((character) => {
|
|
const existing = byId.get(character.id)
|
|
if (existing) return existing
|
|
const on = newCharacterId && character.id === newCharacterId
|
|
? i === turnOnIndex
|
|
: true
|
|
return defaultCharacterState(character.id, on)
|
|
})
|
|
}
|
|
}
|
|
|
|
/** Ensure every scene has a state row for every sequence set. */
|
|
export function ensureSceneStatesForSets(
|
|
scenes: PromptSequenceScene[],
|
|
sets: PromptSequenceSet[],
|
|
opts?: { newSetId?: string; turnOnSceneIndex?: number }
|
|
) {
|
|
const newSetId = opts?.newSetId
|
|
const turnOnIndex = opts?.turnOnSceneIndex
|
|
for (let i = 0; i < scenes.length; i++) {
|
|
const scene = scenes[i]
|
|
const byId = new Map((scene.setStates || []).map(state => [state.setId, state]))
|
|
scene.setStates = sets.map((set) => {
|
|
const existing = byId.get(set.id)
|
|
if (existing) return existing
|
|
const on = newSetId && set.id === newSetId
|
|
? i === turnOnIndex
|
|
: true
|
|
return defaultSetState(set.id, on)
|
|
})
|
|
}
|
|
}
|