Communitygithub.com

JantonioFC/skillsbank

Photopea in Web-Apps mit photopea.js einbetten. Umfasst Einbettung, Datei-I/O, Scripting, Export, Ebenen, Text, Filter und die vollständige Photoshop-kompatible API.

Was ist skillsbank?

Diese Fähigkeit dient dazu, Photopea als vollwertigen Bildeditor nahtlos in Webanwendungen zu integrieren. Sie nutzt die Bibliothek `photopea.js`, eine Promise-basierte JavaScript-Wrapper um die Live-Messaging-API von Photopea. Hauptanwendungsfälle sind das Öffnen und Bearbeiten von Bildern, das Ausführen von JavaScript-Skripten innerhalb der Photopea-Umgebung, das Exportieren von Ergebnissen sowie die Automatisierung von Arbeitsabläufen wie Batch-Watermarking. Die Bibliothek ist sowohl über CDN als auch als npm-Paket verfügbar und passt in Frameworks wie React. Die Fähigkeit bietet eine umfassende Referenz der Scripting-API, die größtenteils mit Adobe Photoshop CC 2015 kompatibel ist, inklusive der Objekte `app`, `Document`, `Layer` und `Selection`. Sie ist ideal für Entwickler, die eine leistungsstarke, browserbasierte Bildbearbeitung in ihrem Produkt benötigen, ohne eine eigene Engine entwickeln zu müssen.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/JantonioFC/skillsbank/tree/HEAD/plugins/antigravity-awesome-skills-claude/skills/photopea-embedded-editor

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Photopea Embedded Editor Fähigkeit

Verwendung von photopea.js (yikuansun/PhotopeaAPI) in Websites und Apps


Wann diese Fähigkeit verwenden

Verwenden Sie diese Fähigkeit für jede Aufgabe, die Folgendes umfasst:

  • Einbetten von Photopea als Bildeditor innerhalb einer Webseite oder Web-App
  • Steuern einer eingebetteten Photopea-Instanz aus Ihrem JavaScript-Code
  • Automatisieren von Bildbearbeitungs-Workflows von einer Host-Seite aus (Dateien öffnen, Skripte ausführen, Ergebnisse exportieren)
  • Entwickeln einer Bildbearbeitungsfunktion in Ihr Produkt mit Photopea als Engine
  • Schreiben von Skripten zur Manipulation von Dokumenten, Ebenen, Text, Auswahlen, Filtern, Farben und Pfaden

Nicht rohe postMessage-Verkabelung verwenden – immer photopea.js als Wrapper verwenden.


Bibliothek: photopea.js

photopea.js ist ein Promise-basierter JavaScript-Wrapper um die Photopea Live-Messaging-API. Repository: https://github.com/yikuansun/PhotopeaAPI npm-Paket: https://www.npmjs.com/package/photopea

Installation

CDN (ohne Build-Schritt)

<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/photopea.min.js"></script>

Selbst gehostet

<script src="./photopea.min.js"></script>

npm (Webpack / Vite / Rollup)

npm install photopea
import Photopea from "photopea";

Kern-API: Die Photopea-Klasse

MethodeBeschreibung
Photopea.createEmbed(container)Erstellt + injiziert den Iframe, wird aufgelöst, wenn bereit
new Photopea(window.parent)Plugin-Modus: umschließt das übergeordnete Fenster
pea.runScript(script)Führt einen JS-String innerhalb von Photopea aus; gibt ein Ausgabearray zurück
pea.loadAsset(arrayBuffer)Lädt eine Binärdatei (Bild, Schriftart, Pinsel usw.)
pea.openFromURL(url, asSmart)Öffnet eine entfernte URL als neues Dokument oder als Smart-Objekt-Ebene
pea.exportImage(type)Exportiert das aktuelle Dokument; gibt Blob zurück ("png" oder "jpg")

Alle Methoden geben Promises zurück – immer await oder .then() verwenden.


Schritt 1 — Einbetten

Das Container-<div> muss vor dem Aufruf von createEmbed eine feste Breite und Höhe haben.

<div id="editor" style="width:1000px; height:650px;"></div>
<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/photopea.min.js"></script>
<script>
  Photopea.createEmbed(document.getElementById("editor")).then(async (pea) => {
    // pea ist bereit
  });
</script>

React:

import { useEffect, useRef } from "react";
import Photopea from "photopea";

export default function Editor() {
  const containerRef = useRef(null);
  const peaRef       = useRef(null);

  useEffect(() => {
    if (!containerRef.current || peaRef.current) return;
    Photopea.createEmbed(containerRef.current).then((pea) => {
      peaRef.current = pea;
    });
  }, []);

  return <div ref={containerRef} style={{ width: "100%", height: "650px" }} />;
}

Schritt 2 — Dateien öffnen

// Entfernte URL → neues Dokument
await pea.openFromURL("https://example.com/design.psd", false);

// Entfernte URL → Smart-Objekt-Ebene im aktuellen Dokument
await pea.openFromURL("https://example.com/overlay.png", true);

// Lokale Datei (Benutzereingabe → ArrayBuffer → loadAsset)
document.getElementById("fileInput").addEventListener("change", async (e) => {
  const buf = await e.target.files[0].arrayBuffer();
  await pea.loadAsset(buf);
});

// Base64-Daten-URI über runScript
await pea.runScript(`app.open("data:image/png;base64,iVBORw0...");`);

Schritt 3 — Skripte ausführen

runScript sendet einen JS-String, gibt ein Array von app.echoToOE(...)-Werten + "done" als letztes zurück.

const result = await pea.runScript(`app.echoToOE("hello");`);
// result → ["hello", "done"]

// Strukturierte Daten zurückgeben
const out = await pea.runScript(`
  app.echoToOE(JSON.stringify({
    width:  app.activeDocument.width,
    height: app.activeDocument.height,
    layers: app.activeDocument.layers.length
  }));
`);
const info = JSON.parse(out[0]);

Schritt 4 — Exportieren

// PNG-Blob (über exportImage)
const blob = await pea.exportImage("png");
document.getElementById("preview").src = URL.createObjectURL(blob);

// JPEG-Blob
const blob = await pea.exportImage("jpg");

// WebP / PSD / qualitätsgesteuertes JPEG über saveToOE
const result = await pea.runScript(`app.activeDocument.saveToOE("webp:0.85");`);
const webpBlob = new Blob([result[0]], { type: "image/webp" });

const result = await pea.runScript(`app.activeDocument.saveToOE("psd:true");`);
const psdBlob  = new Blob([result[0]], { type: "application/octet-stream" });

// Download auslösen
async function download(pea, filename = "export.png") {
  const blob = await pea.exportImage("png");
  const a    = Object.assign(document.createElement("a"), {
    href:     URL.createObjectURL(blob),
    download: filename
  });
  a.click();
}

Export-Format-Strings für saveToOE:

StringFormat
"png"PNG verlustfrei
"jpg"JPEG Standard
"jpg:0.8"JPEG-Qualität 0.0–1.0
"webp:0.7"WebP-Qualität 0.0–1.0
"psd"Volles PSD
"psd:true"Minifiziertes PSD
"svg:true"SVG

Schritt 5 — Assets laden

// Schriftart
const buf = await (await fetch("https://example.com/MyFont.otf")).arrayBuffer();
await pea.loadAsset(buf);
// Jetzt in textItem.font verwendbar

// Pinsel
await pea.loadAsset(await (await fetch("Nature.ABR")).arrayBuffer());

// Verlauf
await pea.loadAsset(await (await fetch("Gradients.GRD")).arrayBuffer());

Schritt 6 — Plugin-Modus

// Ihre Seite befindet sich im Seiten-Iframe von Photopea
const pea = new Photopea(window.parent);

const out = await pea.runScript(`app.echoToOE(app.activeDocument.width);`);
console.log("Breite:", out[0]);

// Ein Asset von Ihrem Plugin laden
const buf = await (await fetch("https://my-assets.com/sticker.png")).arrayBuffer();
await pea.loadAsset(buf);

Plugin-Konfiguration:

{
  "environment": {
    "plugins": [{
      "name": "Mein Plugin",
      "url":  "https://my-plugin.example.com",
      "icon": "===https://my-plugin.example.com/icon.png"
    }]
  }
}

Hilfsmuster

addImageAndWait — robuste asynchrone Ebeneneinfügung

async function addImageAndWait(pea, imgURI) {
  let count = "done";
  while (count === "done")
    count = (await pea.runScript(`app.echoToOE(app.activeDocument.layers.length)`))[0];
  count = parseInt(count);

  const imageUrlLiteral = JSON.stringify(imgURI);
  await pea.runScript(`app.open(${imageUrlLiteral}, null, true);`);

  return new Promise((resolve) => {
    const check = async () => {
      const n = parseInt((await pea.runScript(
        `app.echoToOE(app.activeDocument.layers.length)`
      ))[0]);
      n === count + 1 ? resolve() : setTimeout(check, 50);
    };
    check();
  });
}

getDocumentAsImage — gibt ein <img>-Element zurück

async function getDocumentAsImage(pea) {
  const result = await pea.runScript(`app.activeDocument.saveToOE('png')`);
  return new Promise((resolve) => {
    const fr = new FileReader();
    fr.addEventListener("load", (e) => {
      const img = new Image(); img.src = e.target.result; resolve(img);
    });
    fr.readAsDataURL(new Blob([result[0]], { type: "image/png" }));
  });
}

Praxis-Muster

Muster A — Öffnen + Export-UI

<input type="file" id="fileInput" accept="image/*,.psd">
<button id="exportBtn">Export PNG</button>
<div id="editor" style="width:100%;height:600px;"></div>
<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/photopea.min.js"></script>
<script>
let pea;
Photopea.createEmbed(document.getElementById("editor")).then(p => pea = p);

document.getElementById("fileInput").addEventListener("change", async e => {
  await pea.loadAsset(await e.target.files[0].arrayBuffer());
});
document.getElementById("exportBtn").addEventListener("click", async () => {
  const blob = await pea.exportImage("png");
  const a = Object.assign(document.createElement("a"), {
    href: URL.createObjectURL(blob), download: "export.png"
  });
  a.click();
});
</script>

Muster B — Vorlage + Text bearbeiten + Export

async function generateCard(pea, name, tagline) {
  await pea.openFromURL("https://example.com/card.psd", false);
  const nameLiteral = JSON.stringify(name);
  const taglineLiteral = JSON.stringify(tagline);
  await pea.runScript(`
    app.activeDocument.layers.getByName("Name").textItem.contents    = ${nameLiteral};
    app.activeDocument.layers.getByName("Tagline").textItem.contents = ${taglineLiteral};
  `);
  return await pea.exportImage("png");
}

Muster C — Batch-Wasserzeichen

async function batchWatermark(pea, imageURLs, watermarkURL) {
  const results = [];
  for (const url of imageURLs) {
    await pea.openFromURL(url, false);
    await pea.openFromURL(watermarkURL, true);
    await pea.runScript(`
      var doc = app.activeDocument, wm = doc.activeLayer;
      wm.translate(doc.width - wm.bounds[2] - 20, doc.height - wm.bounds[3] - 20);
      wm.opacity = 70;
    `);
    results.push(await pea.exportImage("png"));
    await pea.runScript(`app.activeDocument.close(SaveOptions.DONOTSAVECHANGES);`);
  }
  return results;
}

VOLLSTÄNDIGE SCRIPTING-API-REFERENZ

Der gesamte Code in diesem Abschnitt wird innerhalb von pea.runScript("...")-Strings ausgeführt. Photopea implementiert die Adobe Photoshop CC 2015 JavaScript-Scripting-Schnittstelle. Jedes Photoshop-Skript, das auf diese Version abzielt, sollte in Photopea funktionieren.


app — Anwendungsobjekt

Eigenschaften

EigenschaftTypL/SBeschreibung
app.activeDocumentDocumentL/SDas aktuell aktive Dokument
app.documentsDocumentsLSammlung aller offenen Dokumente
app.documents.lengthnumberLAnzahl der offenen Dokumente
app.documents[i]DocumentLZugriff über nullbasierten Index
app.foregroundColorSolidColorL/SAktuelle Vordergrundfarbe
app.backgroundColorSolidColorL/SAktuelle Hintergrundfarbe
app.preferences.rulerUnitsUnitsL/SUnits.PIXELS, Units.CM, Units.INCHES, Units.MM, Units.PICAS, Units.POINTS, Units.PERCENT
app.preferences.typeUnitsTypeUnitsL/STypeUnits.PIXELS, TypeUnits.MM, TypeUnits.POINTS
app.displayDialogsDialogModesL/SDialogModes.NO, DialogModes.ALL, DialogModes.ERROR

Methoden

MethodeBeschreibung
app.open(url)URL als neues Dokument öffnen
app.open(url, null, true)URL als Smart-Objekt-Ebene im aktiven Dokument öffnen
app.echoToOE(string)Photopea-Erweiterung — Sendet einen String an die Host-Seite (von runScript erfasst)
app.showWindow("magiccut")Photopea-Erweiterung — Magic Cut-Bedienfeld öffnen
app.showWindow("vbitmap")Photopea-Erweiterung — Bitmap vektorisieren-Bedienfeld öffnen
app.UI.zoomIn()Vergrößern
app.UI.zoomOut()Verkleinern
app.UI.fitTheArea()Leinwand an Ansichtsfenster anpassen
app.UI.pixelToPixel()100% Zoom
app.UI.switchFullscreen()Vollbild umschalten
app.UI.scroll(dx, dy)Um Delta scrollen
app.UI.scrollTo(x, y)Zu absoluter Position scrollen

Wichtig: Setzen Sie die Linealeinheiten immer zu Beginn eines Skripts, das Pixelmaße verwendet, auf Pixel:

var savedUnits = app.preferences.rulerUnits;
app.preferences.rulerUnits = Units.PIXELS;
// ... Ihr Code ...
app.preferences.rulerUnits = savedUnits;

Document — Dokumentobjekt

Zugriff über app.activeDocument oder app.documents[i].

Eigenschaften

EigenschaftTypL/SBeschreibung
widthnumberLDokumentbreite in aktuellen Linealeinheiten
heightnumberLDokumenthöhe in aktuellen Linealeinheiten
resolutionnumberLDPI (Pixel pro Zoll)
namestringL/SPhotopea-Erweiterung — Anzeigelabel (kein Historienschritt)
sourcestringL/SPhotopea-Erweiterung — Datei-Ursprungs-URL oder "local,X,NAME"
modeDocumentModeLDocumentMode.RGB, GRAYSCALE, CMYK, LAB, BITMAP, INDEXEDCOLOR, MULTICHANNEL
bitsPerChannelBitsPerChannelTypeLBitsPerChannelType.EIGHT, SIXTEEN, THIRTYTWO
colorProfileNamestringLName des eingebetteten Farbprofils
activeLayerLayer/ArtLayer/LayerSetL/SSetzen, um eine Ebene zu aktivieren
currentLayerArtLayerL/SAlias für activeLayer
layersLayersLAlle obersten Ebenen (sowohl Art als auch Gruppe)
artLayersArtLayersLNur alle obersten Art-Ebenen
layerSetsLayerSetsLNur alle obersten Gruppenebenen
selectionSelectionLDie aktuelle Auswahl
channelsChannelsLAlle Kanäle
historyStatesHistoryStatesLRückgängig-Verlauf
activeHistoryStateHistoryStateL/SAktuelle Verlaufsposition
layerCompsLayerCompsLEbenenkompositionen-Sammlung
guidesGuidesLHilfslinien-Sammlung
pathItemsPathItemsLVektorpfade
idnumberLEindeutige Dokument-ID
savedbooleanLOb das Dokument ungespeicherte Änderungen hat
quickMaskModebooleanLOb im Schnellmasken-Modus
backgroundLayerArtLayerLDie Hintergrundebene
pixelAspectRationumberLBenutzerdefiniertes Pixel-Seitenverhältnis (0.1–10.0)
histogramarrayL256-Element-Histogramm-Array

Methoden

MethodeSignaturBeschreibung
resizeImage(w, h, res, resampleMethod)Bildpixel in der Größe ändern. ResampleMethod: BICUBIC, BILINEAR, NEARESTNEIGHBOR, NONE, BICUBICSHARPER, BICUBICSMOOTHER
resizeCanvas(w, h, anchor)Leinwand ohne Skalierung in der Größe ändern. AnchorPosition: TOPLEFT, TOPCENTER, TOPRIGHT, MIDDLELEFT, MIDDLECENTER, MIDDLERIGHT, BOTTOMLEFT, BOTTOMCENTER, BOTTOMRIGHT
rotateCanvas(degrees)Gesamte Leinwand drehen. Positiv = im Uhrzeigersinn
flipCanvas(direction)Direction.HORIZONTAL oder Direction.VERTICAL
crop([x1,y1,x2,y2], angle, w, h)Leinwand zuschneiden. Winkel und Abmessungen sind optional
trim(trimType, top, left, bottom, right)Beschneiden auf Basis von Pixeln. Alle Parameter optional
flatten()Ebenen reduzieren
mergeVisibleLayers()Sichtbare Ebenen zusammenführen
close(SaveOptions)Dokument schließen (SaveOptions.DONOTSAVECHANGES, SAVECHANGES, PROMPTTOSAVECHANGES)
saveAs(url)Als PSD speichern. Dateipfad-URL erforderlich
saveToOE(formatStr)Photopea-Erweiterung — Dokument als Byte-Stream für OE-Export speichern (zurück in Host-Seiten-JS)
duplicate(name, mergeLayersOnly)Dokument duplizieren
link(url)Place Smart-Objekt verknüpft (ersetzt die eingebettete Datei)
revert()Rückgängig machen zuletzt gespeicherter Version
paste(pasteIntoSelection)Zwischenablage einfügen
autoContrast()Automatischen Kontrast anwenden
autoColor()Automatische Farbe anwenden
autoTone()Automatischen Tonwert anwenden
applyImage(sourceDoc, sourceChannel, blendMode, opacity)Bild anwenden
calculations(...)Berechnungen (wie Photoshop)
selectAll()Alle auswählen
selectSimilar()Ähnliches auswählen (alpha-ähnlich)
expandSelection(by)Auswahl erweitern (in Pixeln)
contractSelection(by)Auswahl verkleinern (in Pixeln)
featherSelection(by)Auswahl weichzeichnen (in Pixeln)
smoothSelection(by)Auswahl glätten (in Pixeln)
invertSelection()Auswahl umkehren
loadSelection(channelName)Kanal-CSD laden (muss in app.channels existieren)
intersectSelection(channelName)Auswahl mit Kanal schneiden
growSelection(by)Auswahl vergrößern (in Pixeln)
colorRange(color, fuzziness)color = RGB-Objekt, fuzziness = 0–255
rasterizeAll()Alle Ebenen rasterisieren
mergeVisibleLayers()Sichtbare Ebenen zusammenführen
mergeVisibleLayersAndGroups()Sichtbare Ebenen und Gruppen zusammenführen
desaturate()Entsättigen (luminosity every px)
invert()Invertieren
posterize(levels)2–255 Stufen
threshold(level)0–255 Schwellenwert
splitChannels()Kanäle aufteilen
mergeChannels(mode)Kanäle mit angegebenem Modus zusammenführen
revealAll()Außerhalb-Leinwand-Inhalt anzeigen (Bild in Leinwand einpassen)
trap(width)Überfüllung, wenn CMYK
deletePsdComments()Alle PSD-Kommentare (Anmerkungen) löschen
set(prop, value)Photoshop-spezifische Anwendungseigenschaften festlegen

Layer — Ebenen-API

Alle Ebenen (ArtLayer + LayerSet) erben von Layer. Zugriff über doc.layers[i], getByName("Name") usw.

Gemeinsame Eigenschaften

EigenschaftTypL/SBeschreibung
namestringL/SEbenenname
visiblebooleanL/SSichtbarkeit
opacitynumberL/S0–100
fillOpacitynumberL/S0–100 (Fülldeckkraft)
blendModeBlendModeL/SBlendMode.NORMAL, MULTIPLY, SCREEN, OVERLAY, DIFFERENCE usw.
lockedbooleanL/SVollständig gesperrt
allLockedbooleanL/SAlle Sperr-Optionen
transparencyLockedbooleanL/STransparenz gesperrt
compositeLockedbooleanL/SBildpixel gesperrt
positionLockedbooleanL/SPosition gesperrt
pxLockedbooleanL/SPixel gesperrt (Alias für compositeLocked)
boundsarrayL[x1,y1,x2,y2] in Pixelkoordinaten relativ zur Leinwand
boundsNoEffectsarrayLGleiche wie bounds, ohne Ebeneneffekte
kindLayerKindLLayerKind.NORMAL, TEXT, SMARTOBJECT, ADJUSTMENT, SHAPE, VIDEO, CLIPGROUP
isBackgroundLayerbooleanL
isTextLayerbooleanL
groupIDnumberL/SPhotopea-Erweiterung — Gruppenebenen-ID (0 = keine Gruppe)
idnumberLEindeutige Ebenen-ID

Methoden

MethodeSignaturBeschreibung
duplicate(relativeObject, insertionLocation)Ebene duplizieren. InsertionLocation: ElementPlacement.INSIDE, INSIDEEND, PLACEBEFORE, PLACEAFTER, PLACEATBEGINNING, PLACEATEND
remove()Ebene löschen
move(relativeObject, insertionLocation)Ebene in der Ebenenreihenfolge verschieben
resize(horiz, vert, anchor)Prozentskala (z. B. 200 = verdoppeln). Optional anchor
scale(horiz, vert, anchor)Alias für resize
rotate(degrees, anchor)Relative Rotation um Mittelpunkt (an der Stelle)
translate(deltaX, deltaY)Um dx, dy Pixel relativ verschieben
translateAbsolute(x, y)An Position (in Pixelkoordinaten) verschieben
flip(direction)Direction.HORIZONTAL oder Direction.VERTICAL
adjustBrightnessContrast(brightness, contrast)Helligkeit/Kontrast anpassen
adjustLevels(inputRange, inputRangeGamma, outputRange, ...)Tonwertkorrektur über Arrays
adjustCurves(channel, curve)curve = Array von Kontrollpunkten [{x,y},...]
adjustColorBalance(shadows, midtones, highlights)Alle drei sind [cy,mg,yel]-Arrays
adjustHueSaturation(hue, saturation, lightness)Alle 0–180, 0–100, -100–100
adjustPhotoFilter(color, density)color = SolidColor, density = 0–100
adjustExposure(exposure, offset, gamma)Alle drei Zahlen
adjustInvert()Invertieren
adjustPosterize(levels)2–255 Stufen
adjustThreshold(level)0–255 Schwellenwert
adjustSelectiveColor(method, colors)method = "relative" oder "absolute", colors = Objekt von Farbkomponenten
adjustGradientMap(gradient)Gradient-Objekt
applyFilter(filterName, settings)Filter anwenden (siehe Filter-Abschnitt unten)
set(prop, value)Photoshop-spezifische Ebeneneigenschaft (z. B. layer.set("layerId", 5))
get(prop)Photoshop-spezifische Ebeneneigenschaft abrufen

ArtLayer — Pixel-/Inhaltsebene

Erbt alle Layer-Eigenschaften + Methoden. Zusätzlich:

EigenschaftBeschreibung
textItemTextItem-Objekt (siehe unten), wenn kind === LayerKind.TEXT, sonst null
smartObjectSmartObject (siehe unten), wenn kind === LayerKind.SMARTOBJECT, sonst null
adjustmentEinstellungstyp (String), wenn kind === LayerKind.ADJUSTMENT
pxDataPhotopea-Erweiterung — Zugriff auf die Pixel (Array/ByteArray) für diese Ebene

LayerSet — Gruppenebene

Erbt alle Layer-Eigenschaften + Methoden. Zusätzlich:

EigenschaftBeschreibung
layersLayers
artLayersArtLayers
layerSetsLayerSets
backgroundBackground
opacitynumber

TextItem — Textebene

Zugriff: layer.textItem (wenn layer.kind === LayerKind.TEXT)

Eigenschaften

EigenschaftTypL/SBeschreibung
contentsstringL/STextinhalt
fontstringL/SSchriftfamilienname
sizenumberL/SSchriftgröße in Punkten (fließend)
colorSolidColorL/STextfarbe
positionarrayL[x,y] Position
fontStylestringL/S„Bold“, „Italic“ usw.
horizontalAlignmentAlignmentL/SAlignment.LEFT, RIGHT, CENTER, JUSTIFIED
verticalAlignmentAlignmentL/SAlignment.TOP, BOTTOM, CENTER
autoKerningbooleanL/SAutomatisches Kerning
baselineShiftnumberL/SIn Punkten
capitalizationCapitalizationL/SCapitalization.NORMAL, UPPERCASE, SMALLCAPS
desiredGlyphScalingnumberL/S50–200 %
desiredLetterScalingnumberL/S-100–500 %
desiredWordScalingnumberL/S50–200 %
directionDirectionL/SDirection.HORIZONTAL oder Direction.VERTICAL
leadingnumberL/SZeilenabstand in Punkten (0 = automatisch)
letterSpacingnumberL/S-100–500 %
ligaturesbooleanL/SLigaturen
maximumGlyphScalingnumberL/S50–200 %
maximumLetterScalingnumberL/S-100–500 %
maximumWordScalingnumberL/S50–200 %
strikeThroughbooleanL/SDurchgestrichen
trackingnumberL/SZeichenabstand in Einheiten (0 = automatisch)
underlinebooleanL/SUnterstrichen
useAutoLeadingbooleanL/SAutomatischer Zeilenabstand
wordSpacingnumberL/SWortabstand (ähnlich letterSpacing)

SmartObject — Smart-Objekt-Ebene

Eigenschaften

EigenschaftBeschreibung
linkedboolean
linkedFileFile
boundsarray

Methoden

MethodeBeschreibung
replaceContents(url)Eingebettete Datei durch neue URL ersetzen
loadPhotopea-Erweiterung — Erzwingt das Laden (für verknüpfte Dateien)
unlinkPhotopea-Erweiterung — Verknüpfung aufheben (eingebettet)

Selection — Auswahlobjekt

Eigenschaften

EigenschaftTypBeschreibung
boundsarray[x1,y1,x2,y2] in Pixeln
solidbooleanIst nicht leer

Methoden

MethodeBeschreibung
clear()Inhalt löschen
fill(color)Mit SolidColor füllen
stroke(color, width, location, blendMode, opacity, preserveTransparency)Umriss zeichnen
contract(by)Verkleinern
expand(by)Erweitern
feather(by)Weichzeichnen
smooth(by)Glätten
grow(by)Vergrößern
load(channelName)CSD aus angegebenem Kanal laden
intersect(channelName)Mit Kanal-CSD schneiden
invert()Umkehren
makeWorkPath(tolerance)In Arbeitspfad umwandeln
select(region, type, feather)Nach Region auswählen (Array von {x,y}-Punkten)
store(channelName)In neuem Kanal speichern

SolidColor — Farbrepräsentation

var color = new SolidColor();
color.rgb.red = 255; color.rgb.green = 100; color.rgb.blue = 0;
// Oder:
var color = { rgb: { red: 0, green: 255, blue: 0 } };

Eigenschaften: .rgb (Objekt mit red/green/blue), .cmyk, .hsl, .gray, .lab.


BlendMode — Konstanten

BlendMode.NORMAL, MULTIPLY, SCREEN, OVERLAY, DIFFERENCE, EXCLUSION, DARKEN, LIGHTEN, COLORDODGE, COLORBURN, LINEARDODGE, LINEARBURN, HARDLIGHT, SOFTLIGHT, VIVIDLIGHT, LINEARLIGHT, PINLIGHT, HARDMIX, DISSOLVE, DIVIDE, ADD, SUBTRACT, HUE, SATURATION, COLOR, LUMINOSITY, PASSTHROUGH, DARKERCOLOR, LIGHTERCOLOR, LIVELINESS, LUMINOSITY_CONTRAST, LINEAR_BURN (BC), LINEAR_BURN_2 (LCC), MIXTURE;


Filter-API

Verwenden Sie layer.applyFilter(name, settings). settings ist ein Objekt — die Eigenschaften variieren pro Filter.

Unschärfe-Filter

applyFilter("BLUR", {}) — Weichzeichnen applyFilter("BLUR_MORE", {}) — Stärker weichzeichnen applyFilter("BOX_BLUR", {radius: 0.5}) — Box-Weichzeichner applyFilter("BLUR_GAUSSIAN", {radius: 0.5}) — Gaußscher Weichzeichner applyFilter("LENS_BLUR", {radius: ...}) — Linsenunschärfe applyFilter("MOTION_BLUR", {distance: 0, angle: 30}) — Bewegungsunschärfe applyFilter("RADIAL_BLUR", {amount: 10, method: "spin"|"zoom", quality: "best"|"good"|"draft"}) — Radialer Weichzeichner applyFilter("SHAPE_BLUR", {shape: "...", radius: 10}) — Form-Weichzeichner applyFilter("SMART_BLUR", {radius: 2, threshold: 25, quality: "LOW"|"MEDIUM"|"HIGH", mode: "NORMAL"|"EDGE_ONLY"|"OVERLAY_EDGE"}) — Selektiver Weichzeichner applyFilter("SURFACE_BLUR", {radius: 2, threshold: 25}) — Oberflächen-Weichzeichner

Rausch-Filter

applyFilter("ADD_NOISE", {distribution: "uniform"|"gaussian", monochromatic: false, amount: 1.0}) — Rauschen hinzufügen applyFilter("DESPECKLE", {}) — Entflecken applyFilter("DUST_AND_SCRATCHES", {radius: 1, threshold: 0}) — Staub und Kratzer applyFilter("MEDIAN", {radius: 1}) — Median applyFilter("REDUCE_NOISE", {strength: 1, preserveDetails: false, reduceColorNoise: 0, sharpenDetails: false}) — Rauschen reduzieren

Scharfzeichnungs-Filter

applyFilter("SHARPEN", {}) — Scharfzeichnen applyFilter("SHARPEN_EDGES", {}) — Kanten scharfzeichnen applyFilter("SHARPEN_MORE", {}) — Stärker scharfzeichnen applyFilter("SMART_SHARPEN", {amount: 100, radius: 1.0, noise: 0, shadowFade: 0, highlightFade: 0, shadowWidth: 5, highlightWidth: 5, remove: "BLUR"|"GAUSSIAN_BLUR"|"MOTION_BLUR"|"LENS_BLUR", angle: 0}) — Selektives Scharfzeichnen applyFilter("UNSHARP_MASK", {amount: 50, radius: 1.0, threshold: 0}) — Unscharf maskieren

Verzerrungs-Filter

applyFilter("DISPLACE", {scale: 10, horizontal: 1, vertical: 1, stretchToFit: true, repeatPixels: false}) — Verschiebungseffekt applyFilter("GLASS", {distortion: 5, smoothness: 3, scaling: 100, invert: false, texture: "..."|"BLOCKS"|"CANVAS"|"FROSTED"|"TINYLENS"|"LOAD_TEXTURE"}) — Glas-Effekt applyFilter("OCEAN_RIPPLE", {size: 9, magnitude: 9}) — Meereswellen applyFilter("PINCH", {amount: 50}) — Verzerrung (positiv = hinein, negativ = heraus) applyFilter("POLAR_COORDINATES", {rectangular: true}) — Polarkoordinaten applyFilter("RIPPLE", {amount: 100, size: "SMALL"|"MEDIUM"|"LARGE"}) — Welle applyFilter("SHEAR", {curve: [[0,0.5],[0.5,0],[1,0.5]], repeat: "wrap"|"repeat", undefined: false}) — Schere applyFilter("SPHERIZE", {amount: 50}) — Sphärisieren applyFilter("TWIRL", {angle: 60}) — Wirbel applyFilter("WAVE", {generators: 5, minWavelength: 10, maxWavelength: 120, minAmplitude: 5, maxAmplitude: 35, scale: [100,100], type: "sine"|"triangle"|"square", repeat: "warp"|"repeat", undefined: false}) — Welle applyFilter("ZIGZAG", {amount: 10, ridges: 10, style: "around_center"|"out_from_center"|"pond_ripples"}) — Zickzack

Pixel-Filter

applyFilter("COLOR_HALFTONE", {maxRadius: 8, angles: [108,162,90,45]}) — Farbhalbton applyFilter("CRYSTALLIZE", {cellSize: 10}) — Kristallisieren applyFilter("FACET", {}) — Facette applyFilter("FRAGMENT", {}) — Fragment applyFilter("MEZZOTINT", {type: "..."}) — Mezzotinto applyFilter("MOSAIC", {cellSize: 10}) — Mosaik applyFilter("POINTILLIZE", {cellSize: 5}) — Punktieren

Render-Filter

applyFilter("CLOUDS", {}) — Wolken applyFilter("DIFFERENCE_CLOUDS", {}) — Differenzwolken applyFilter("FIBERS", {variance: 16, strength: 4}) — Fasern applyFilter("LENS_FLARE", {brightness: 100, x: 0.5, y: 0.5, lens: "50_300"|"35"|"105"|"MOVIE"}) — Blendenfleck applyFilter("LIGHTING_EFFECTS", {...}) — Beleuchtungseffekte

Stilisierungs-Filter

applyFilter("DIFFUSE", {mode: "NORMAL"|"LIGHTEN_ONLY"|"DARKEN_ONLY", anisotropy: 1}) — Diffuses Licht applyFilter("EMBOSS", {angle: 135, height: 3, amount: 100}) — Prägen applyFilter("EXTRUDE", {type: "blocks"|"pyramids", size: 30, depth: 30, random: true, solidFront: false, maskIncomplete: true}) — Extrudieren applyFilter("FIND_EDGES", {}) — Kanten suchen applyFilter("GLOWING_EDGES", {edgeWidth: 1, edgeBrightness: 0, smoothness: 1}) — Leuchtende Kanten applyFilter("SOLARIZE", {}) — Solarisieren applyFilter("TILES", {number: 10, maxOffset: 10, fill: "Background"|"Foreground"|"InverseImage"|"Unchanged"}) — Kacheln applyFilter("TRACE_CONTOUR", {level: 128, edge: "lower"|"upper"}) — Kontourlinie nachziehen applyFilter("WIND", {method: "wind"|"blast"|"stagger", direction: "right"|"left"|"up"|"down"}) — Wind

Video-Filter

applyFilter("NTSC_COLORS", {}) — NTSC-Farben applyFilter("DEINTERLACE", {method: "duplicate"|"interpolation"}) — Zeilenentflechtung

Sonstige Filter

applyFilter("CUSTOM", {matrix: [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], scale: 1, offset: 0}) — Benutzerdefiniert applyFilter("HIGH_PASS", {radius: 6}) — Hochpass applyFilter("MAXIMUM", {radius: 2}) — Maximum applyFilter("MINIMUM", {radius: 1}) — Minimum applyFilter("OFFSET", {horizontal: 0, vertical: 0, repeat: "wrap"|"repeat"|"setToBackground"}) — Verschiebung applyFilter("RECOLOR", {}) — Neu einfärben applyFilter("SHADOWS_HIGHLIGHTS", {shadowAmount: 35, tonalWidth: 50, radius: 30, highlightAmount: 0}) — Tiefen/Lichter applyFilter("EQUALIZE", {}) — Tonwertangleichung


Weitere Objekte

Channel

EigenschaftBeschreibung
nameKanalkomp.: "rot", "grün", "blau" usw.
kind"COMPONENT" für rot/grün/blau, "MASK" für benutzerdefiniert
visibleSichtbarkeit
opacity0–100
histogram256-Elemente-Array

Guide

EigenschaftBeschreibung
directionDirection.HORIZONTAL oder Direction.VERTICAL
valuePosition (in Linealeinheiten)

HistoryState

EigenschaftBeschreibung
nameString
targetDocument, ArtLayer, Selection, Channel
sourceHistoryState

LayerComp

EigenschaftBeschreibung
nameString
commentString
appearanceboolean
positionboolean
visibilityboolean
selectedboolean
activeboolean

Methoden: apply(), delete(), duplicate(), recapture().

PathItem

EigenschaftBeschreibung
nameString
kindPathKind
subPathItemsArray von SubPathItem

SubPathItem

EigenschaftBeschreibung
closedboolean
pathPointsArray von PathPoint

PathPoint

EigenschaftBeschreibung
anchorArray [x,y]
leftDirection//
rightDirection//
kindPointKind (SMOOTH/CORNER)

Wichtige Photopea-Scripting-Hinweise

  1. Immer zuerst Linealeinheiten speichern und auf Pixel setzen. Standard ist Zoll — viele APIs (bounds, resize, position) arbeiten in Linealeinheiten.

  2. Ebenenzugriff ist nullbasiert: doc.layers[0] = unterste Ebene.

  3. Stapelverarbeitung: Öffnen Sie mehrere URLs mit openFromURL; Photopea öffnet alle nebeneinander. Wechseln Sie Dokumente über app.activeDocument = doc oder verwenden Sie doc.id.

  4. Kein direkter DOM-Zugriff von Skripten — kein document.querySelector; verwendet app.echoToOE, um Daten an den Host zurückzugeben.

  5. Asynchrone Wartezeit: Nach dem Laden von Assets oder dem Öffnen von Dokumenten müssen Skripte möglicherweise kurz warten, bis die Verarbeitung abgeschlossen ist. Das Muster addImageAndWait oben zeigt, wie man dies robust handhabt.

  6. Fehlerbehandlung: runScript wird abgelehnt, wenn Ihr Skript einen unbehandelten Fehler auslöst. Verwenden Sie immer Try-Catch innerhalb Ihres Skript-Strings oder behandeln Sie den abgelehnten Promise auf der Host-Seite.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

JantonioFC/skillsbank

AI-powered image editing with style transfer and object removal

JantonioFC/skillsbank

Internationalization and localization patterns. Detecting hardcoded strings, managing translations, locale files, RTL support.

JantonioFC/skillsbank

Analise e auditoria de editais de leilao judicial e extrajudicial. Riscos ocultos, clausulas perigosas, debitos, ocupante e classificacao da oportunidade.

JantonioFC/skillsbank

Best practices for Remotion - Video creation in React

JantonioFC/skillsbank

Generate walkthrough videos from Stitch projects using Remotion with smooth transitions, zooming, and text overlays

JantonioFC/skillsbank

Seek and analyze video content using Memories.ai Large Visual Memory Model for persistent video intelligence

JantonioFC/skillsbank

Writes complete, structured landing pages optimized for SEO ranking, AEO citation, and visitor conversion. Activate when the user wants to write or generate a landing page for a product, service, or offer.

JantonioFC/skillsbank

Video and audio perception, indexing, and editing. Ingest files/URLs/live streams, build visual/spoken indexes, search with timestamps, edit timelines, add overlays/subtitles, generate media, and create real-time alerts.

JantonioFC/skillsbank

Upload, stream, search, edit, transcribe, and generate AI video and audio using the VideoDB SDK.

JantonioFC/skillsbank

Skill for discovering and researching autonomous AI agents, tools, and ecosystems using the AgentFolio directory.

JantonioFC/skillsbank

Expert in building portfolios that actually land jobs and clients - not just showing work, but creating memorable experiences. Covers developer portfolios, designer portfolios, creative portfolios, and portfolios that convert visitors into opportunities.

JantonioFC/skillsbank

Tool lifecycle UI components for React/Next.js from ui.inference.sh. Display tool calls: pending, progress, approval required, results. Capabilities: tool status, progress indicators, approval flows, results display. Use for: showing agent tool calls, human-in-the-loop approvals, tool output. Triggers: tool ui, tool calls, tool status, tool approval, tool results, agent tools, mcp tools ui, function calling ui, tool lifecycle, tool pending

JantonioFC/skillsbank

Security audit, hardening, threat modeling (STRIDE/PASTA), Red/Blue Team, OWASP checks, code review, incident response, and infrastructure security for any project.

JantonioFC/skillsbank

When the user wants help with paid advertising campaigns on Google Ads, Meta (Facebook/Instagram), LinkedIn, Twitter/X, or other ad platforms. Also use when the user mentions 'PPC,' 'paid media,' 'ROAS,' 'CPA,' 'ad campaign,' 'retargeting,' 'audience targeting,' 'Google Ads,' 'Facebook ads,'...

JantonioFC/skillsbank

Create AI avatar and talking head videos with OmniHuman, Fabric, PixVerse via inference.sh CLI. Models: OmniHuman 1.5, OmniHuman 1.0, Fabric 1.0, PixVerse Lipsync. Capabilities: audio-driven avatars, lipsync videos, talking head generation, virtual presenters. Use for: AI presenters, expla...

JantonioFC/skillsbank

Create AI marketing videos for ads, promos, product launches, and brand content. Models: Veo, Seedance, Wan, FLUX for visuals, Kokoro for voiceover. Types: product demos, testimonials, explainers, social ads, brand videos. Use for: Facebook ads, YouTube ads, product launches, brand awarene...

JantonioFC/skillsbank

Generate AI videos with Google Veo, Seedance, Wan, Grok and 40+ models via inference.sh CLI. Models: Veo 3.1, Veo 3, Seedance 1.5 Pro, Wan 2.5, Grok Imagine Video, OmniHuman, Fabric, HunyuanVideo. Capabilities: text-to-video, image-to-video, lipsync, avatar animation, video upscaling, fole...

JantonioFC/skillsbank

Production-ready CI/CD configurations for Playwright — GitHub Actions, GitLab CI, CircleCI, Azure DevOps, Jenkins, Docker, parallel sharding, reporting, code coverage, and global setup/teardown.

JantonioFC/skillsbank

Next.js 16+ and Turbopack — incremental bundling, FS caching, dev speed, and when to use Turbopack vs webpack.

JantonioFC/skillsbank

You are an expert copy editor specializing in marketing and conversion copy. Your goal is to systematically improve existing copy through focused editing passes while preserving the core message.

Verwandte Skills