Auto-Photoshop-StableDiffusion-Plugin/utility/session.js

const { cleanLayers } = require("../psapi")

const SessionState = {
  Active: "active",
  Inactive: "inactive",
}
const GarbageCollectionState = {
  Accept: "accept", // accept all generated images
  Discard: "discard", //discard all generated images
  DiscardSelected: "discard_selected",
  AcceptSelected: "accept_selected", //accept_selected only chosen images
}

class GenerationSession {
  constructor() {
    //this should be unique session id and it also should act as the total number of sessions been created in the project
    this.id = 0
    this.state = SessionState["Inactive"]
    this.mode = "txt2img"
    this.selectionInfo = null
    this.isFirstGeneration = true // only before the first generation is requested should this be true
    this.outputGroup
    this.prevOutputGroup
    this.isLoadingActive = false
  }
  isActive() {
    return this.state === SessionState["Active"]
  }
  isInactive() {
    return this.state === SessionState["Inactive"]
  }
  activate() {
    this.state = SessionState["Active"]
  }
  deactivate() {
    this.state = SessionState["Inactive"]
  }
  name() {
    return `session - ${this.id}`
  }
  async startSession() {
    this.id += 1 //increment the session id for each session we start
    this.activate()
    this.isFirstGeneration = true // only before the first generation is requested should this be true

    console.log("current session id: ", this.id)
    try {
      const session_name = this.name()
      const activeLayers = await app.activeDocument.activeLayers
      await psapi.unselectActiveLayersExe() // unselect all layer so the create group is place at the top of the document
      this.prevOutputGroup = this.outputGroup
      const outputGroup = await psapi.createEmptyGroup(session_name)
      this.outputGroup = outputGroup
      await psapi.selectLayersExe(activeLayers)
    } catch (e) {
      console.warn(e)
    }
  }
  async endSession(garbage_collection_state) {
    try {
      this.state = SessionState["Inactive"] // end the session by deactivate it

      this.deactivate()

      if (garbage_collection_state === GarbageCollectionState["Accept"]) {
        await acceptAll()
      } else if (
        garbage_collection_state === GarbageCollectionState["Discard"]
      ) {
        //this should be discardAll()

        await discardAll()
      } else if (
        garbage_collection_state === GarbageCollectionState["DiscardSelected"]
      ) {
        //this should be discardAllExcept(selectedLayers)
        await discardSelected() //this will discard what is not been highlighted
      } else if (
        garbage_collection_state === GarbageCollectionState["AcceptSelected"]
      ) {
        //this should be discardAllExcept(selectedLayers)
        await discard() //this will discard what is not been highlighted
      }

      //delete the old selection area
      // g_selection = {}

      this.isFirstGeneration = true // only before the first generation is requested should this be true
      // const is_visible = await this.outputGroup.visible
      await util_layer.collapseFolderExe([this.outputGroup], false) // close the folder group
      // this.outputGroup.visible = is_visible

      if (
        this.mode === generationMode["Inpaint"] &&
        g_sd_mode === generationMode["Inpaint"]
      ) {
        //create "Mask -- Paint White to Mask -- temporary" layer if current session was inpiant and the selected session is inpaint
        // the current inpaint session ended on inpaint
        g_b_mask_layer_exist = false
        await util_layer.deleteLayers([g_inpaint_mask_layer])
        await createTempInpaintMaskLayer()
      }
    } catch (e) {
      console.warn(e)
    }
  }
  async closePreviousOutputGroup() {
    try {
      //close the previous output folder

      if (this.prevOutputGroup) {
        // const is_visible = await this.prevOutputGroup.visible
        await util_layer.collapseFolderExe([this.prevOutputGroup], false) // close the folder group
        // and reselect the current output folder for clarity
        await psapi.selectLayersExe([this.outputGroup])
        // this.prevOutputGroup.visible = is_visible
      }
    } catch (e) {
      console.warn(e)
    }
  }
  isSameMode(selected_mode) {
    if (this.mode === selected_mode) {
      return true
    }
    return false
  }
  loadLastSession() {
    //load the last session from the server
  }
  saveCurrentSession() {
    //all session info will be saved in a json file in the project folder
  }
  async moveToTopOfOutputGroup(layer) {
    const output_group_id = await this.outputGroup.id
    let group_index = await psapi.getLayerIndex(output_group_id)
    const indexOffset = 1 //1 for background, 0 if no background exist
    await executeAsModal(async () => {
      await psapi.moveToGroupCommand(group_index - indexOffset, layer.id)
    })
  }
}

module.exports = {
  GenerationSession,
  GarbageCollectionState,
  SessionState,
}