3222 lines
113 KiB
JavaScript
3222 lines
113 KiB
JavaScript
/*
|
|
* Extracted from browser-delivered Turbopack chunk: 09166d9658efb080.e1742a6c63.js
|
|
* Module id: 929286
|
|
* For reading/searching only; this factory depends on the original Turbopack runtime.
|
|
*/
|
|
|
|
const moduleFactory = (e) => {
|
|
"use strict";
|
|
let t;
|
|
e.i(23741);
|
|
var n = e.i(462214),
|
|
o = e.i(358379),
|
|
i = e.i(888255),
|
|
r = e.i(396805),
|
|
a = e.i(744027),
|
|
s = e.i(834308),
|
|
l = e.i(768924),
|
|
d = e.i(226508),
|
|
u = e.i(410985),
|
|
c = e.i(144963),
|
|
p = e.i(417754),
|
|
h = e.i(677418),
|
|
g = e.i(713118),
|
|
f = e.i(799545),
|
|
m = e.i(182004),
|
|
y = e.i(733077);
|
|
let v = null;
|
|
function w(e) {
|
|
v = e;
|
|
}
|
|
let x = { current: !1 };
|
|
function S(e, t, n) {
|
|
if (t && !n && e.some((e) => "select" === e.type)) {
|
|
if (x.current) {
|
|
x.current = !1;
|
|
return;
|
|
}
|
|
v?.();
|
|
}
|
|
}
|
|
e.s(
|
|
[
|
|
"afterApplyNodeChangesClipTimelineSync",
|
|
() => S,
|
|
"registerClearEmbedClipTimelineSelection",
|
|
() => w,
|
|
"suppressCanvasSelectionDrivenTimelineClearRef",
|
|
0,
|
|
x,
|
|
],
|
|
689625,
|
|
);
|
|
var b = e.i(325528),
|
|
I = e.i(640958);
|
|
function _(e, t) {
|
|
if (0 === e.length) return 0;
|
|
let n = Math.ceil((t / 100) * e.length) - 1;
|
|
return e[Math.max(0, n)];
|
|
}
|
|
let E = 0;
|
|
class M {
|
|
static _instance = null;
|
|
_sessionId = "";
|
|
_sessionStart = 0;
|
|
_samples = new Map();
|
|
_metrics = new Map();
|
|
_fpsSamples = [];
|
|
_fpsAnimFrame = null;
|
|
_fpsLastTime = 0;
|
|
_fpsFrameCount = 0;
|
|
_isActive = !1;
|
|
_fpsPaused = !1;
|
|
static getInstance() {
|
|
return M._instance || (M._instance = new M()), M._instance;
|
|
}
|
|
startSession(e) {
|
|
this._isActive && this.endSession(),
|
|
E++,
|
|
(this._sessionId = `perf-${Date.now()}-${E}`),
|
|
(this._sessionStart = performance.now()),
|
|
this._samples.clear(),
|
|
this._metrics.clear(),
|
|
(this._fpsSamples = []),
|
|
(this._isActive = !0),
|
|
this.startFpsMonitor();
|
|
}
|
|
endSession() {
|
|
return this._isActive
|
|
? (this.stopFpsMonitor(), (this._isActive = !1), this.getSummary())
|
|
: null;
|
|
}
|
|
get isActive() {
|
|
return this._isActive;
|
|
}
|
|
startMeasure(e) {
|
|
if (!this._isActive) return () => 0;
|
|
let t = performance.now();
|
|
return (n) => {
|
|
let o = performance.now() - t;
|
|
return this.recordSample(e, o, n?.success), o;
|
|
};
|
|
}
|
|
recordSample(e, t, n) {
|
|
if (!this._isActive) return;
|
|
let o = {
|
|
operation: e,
|
|
durationMs: t,
|
|
timestamp: Date.now(),
|
|
success: n,
|
|
},
|
|
i = this._samples.get(e);
|
|
i || ((i = []), this._samples.set(e, i)),
|
|
i.push(o),
|
|
i.length > 500 && i.splice(0, i.length - 500);
|
|
}
|
|
recordMetric(e, t, n) {
|
|
this._isActive &&
|
|
this._metrics.set(e, {
|
|
name: e,
|
|
value: t,
|
|
timestamp: Date.now(),
|
|
tags: n,
|
|
});
|
|
}
|
|
getSummary() {
|
|
let e,
|
|
t = this._isActive ? performance.now() - this._sessionStart : 0,
|
|
n = {};
|
|
for (let [e, t] of this._samples) {
|
|
if (0 === t.length) continue;
|
|
let o = t.map((e) => e.durationMs).sort((e, t) => e - t),
|
|
i = t.filter((e) => !1 !== e.success).length;
|
|
n[e] = {
|
|
count: t.length,
|
|
avgMs: o.reduce((e, t) => e + t, 0) / o.length,
|
|
p50Ms: _(o, 50),
|
|
p95Ms: _(o, 95),
|
|
p99Ms: _(o, 99),
|
|
maxMs: o[o.length - 1],
|
|
minMs: o[0],
|
|
successRate: t.length > 0 ? i / t.length : 1,
|
|
};
|
|
}
|
|
let o = {};
|
|
for (let [e, t] of this._metrics) o[e] = t.value;
|
|
if (this._fpsSamples.length > 0) {
|
|
let t = [...this._fpsSamples].sort((e, t) => e - t);
|
|
e = {
|
|
avg: t.reduce((e, t) => e + t, 0) / t.length,
|
|
min: t[0],
|
|
p5: _(t, 5),
|
|
};
|
|
}
|
|
return {
|
|
sessionId: this._sessionId,
|
|
sessionDurationMs: Math.round(t),
|
|
operations: n,
|
|
latestMetrics: o,
|
|
fps: e,
|
|
};
|
|
}
|
|
getRecentSamples(e, t = 20) {
|
|
return (this._samples.get(e) ?? []).slice(-t);
|
|
}
|
|
pauseFps() {
|
|
this._fpsPaused || ((this._fpsPaused = !0), this.stopFpsMonitor());
|
|
}
|
|
resumeFps() {
|
|
this._fpsPaused &&
|
|
((this._fpsPaused = !1), this._isActive && this.startFpsMonitor());
|
|
}
|
|
startFpsMonitor() {
|
|
if ("u" < typeof requestAnimationFrame) return;
|
|
(this._fpsLastTime = performance.now()), (this._fpsFrameCount = 0);
|
|
let e = () => {
|
|
if (!this._isActive || this._fpsPaused) return;
|
|
this._fpsFrameCount++;
|
|
let t = performance.now(),
|
|
n = t - this._fpsLastTime;
|
|
if (n >= 1e3) {
|
|
let e = (this._fpsFrameCount / n) * 1e3;
|
|
this._fpsSamples.push(e),
|
|
this._fpsSamples.length > 120 &&
|
|
this._fpsSamples.splice(0, this._fpsSamples.length - 120),
|
|
(this._fpsLastTime = t),
|
|
(this._fpsFrameCount = 0);
|
|
}
|
|
this._fpsAnimFrame = requestAnimationFrame(e);
|
|
};
|
|
this._fpsAnimFrame = requestAnimationFrame(e);
|
|
}
|
|
stopFpsMonitor() {
|
|
null !== this._fpsAnimFrame &&
|
|
(cancelAnimationFrame(this._fpsAnimFrame),
|
|
(this._fpsAnimFrame = null));
|
|
}
|
|
reset() {
|
|
this.endSession(),
|
|
this._samples.clear(),
|
|
this._metrics.clear(),
|
|
(this._fpsSamples = []);
|
|
}
|
|
}
|
|
function C() {
|
|
return M.getInstance();
|
|
}
|
|
e.s(["getCanvasPerformance", () => C], 763026);
|
|
let N = "pending-ops";
|
|
function P() {
|
|
return new Promise((e, t) => {
|
|
let n = indexedDB.open("liblibtv-sync", 1);
|
|
(n.onupgradeneeded = () => {
|
|
let e = n.result;
|
|
e.objectStoreNames.contains(N) ||
|
|
e.createObjectStore(N, { keyPath: "id", autoIncrement: !0 });
|
|
}),
|
|
(n.onsuccess = () => e(n.result)),
|
|
(n.onerror = () => t(n.error ?? Error("IndexedDB open failed")));
|
|
});
|
|
}
|
|
async function k(e, t) {
|
|
try {
|
|
let n = await P(),
|
|
o = n.transaction(N, "readwrite"),
|
|
i = o.objectStore(N),
|
|
r = { projectUuid: e, operation: t, createdAt: Date.now() };
|
|
i.add(r),
|
|
await new Promise((e, t) => {
|
|
(o.oncomplete = () => e()),
|
|
(o.onerror = () =>
|
|
t(o.error ?? Error("IndexedDB transaction failed")));
|
|
}),
|
|
n.close();
|
|
} catch (e) {
|
|
console.warn("[SyncStorage] 持久化操作失败:", e);
|
|
}
|
|
}
|
|
async function T(e) {
|
|
try {
|
|
let t = await P(),
|
|
n = t.transaction(N, "readonly").objectStore(N),
|
|
o = await new Promise((e, t) => {
|
|
let o = n.getAll();
|
|
(o.onsuccess = () => e(o.result)),
|
|
(o.onerror = () =>
|
|
t(o.error ?? Error("IndexedDB request failed")));
|
|
});
|
|
return (
|
|
t.close(),
|
|
o
|
|
.filter((t) => t.projectUuid === e)
|
|
.sort((e, t) => e.createdAt - t.createdAt)
|
|
.map((e) => e.operation)
|
|
);
|
|
} catch (e) {
|
|
return console.warn("[SyncStorage] 加载持久化操作失败:", e), [];
|
|
}
|
|
}
|
|
async function O(e) {
|
|
try {
|
|
let t = await P(),
|
|
n = t.transaction(N, "readwrite"),
|
|
o = n.objectStore(N),
|
|
i = await new Promise((e, t) => {
|
|
let n = o.getAll();
|
|
(n.onsuccess = () => e(n.result)),
|
|
(n.onerror = () =>
|
|
t(n.error ?? Error("IndexedDB request failed")));
|
|
}),
|
|
r = o.getAllKeys(),
|
|
a = await new Promise((e, t) => {
|
|
(r.onsuccess = () => e(r.result)),
|
|
(r.onerror = () =>
|
|
t(r.error ?? Error("IndexedDB request failed")));
|
|
});
|
|
for (let t = 0; t < i.length; t++)
|
|
i[t].projectUuid === e && o.delete(a[t]);
|
|
await new Promise((e, t) => {
|
|
(n.oncomplete = () => e()),
|
|
(n.onerror = () =>
|
|
t(n.error ?? Error("IndexedDB transaction failed")));
|
|
}),
|
|
t.close();
|
|
} catch (e) {
|
|
console.warn("[SyncStorage] 清除持久化操作失败:", e);
|
|
}
|
|
}
|
|
async function A() {
|
|
try {
|
|
let e = await P(),
|
|
t = e.transaction(N, "readwrite"),
|
|
n = t.objectStore(N),
|
|
o = Date.now(),
|
|
i = await new Promise((e, t) => {
|
|
let o = n.getAll();
|
|
(o.onsuccess = () => e(o.result)),
|
|
(o.onerror = () =>
|
|
t(o.error ?? Error("IndexedDB request failed")));
|
|
}),
|
|
r = n.getAllKeys(),
|
|
a = await new Promise((e, t) => {
|
|
(r.onsuccess = () => e(r.result)),
|
|
(r.onerror = () =>
|
|
t(r.error ?? Error("IndexedDB request failed")));
|
|
});
|
|
for (let e = 0; e < i.length; e++)
|
|
o - i[e].createdAt > 864e5 && n.delete(a[e]);
|
|
await new Promise((e, n) => {
|
|
(t.oncomplete = () => e()),
|
|
(t.onerror = () =>
|
|
n(t.error ?? Error("IndexedDB transaction failed")));
|
|
}),
|
|
e.close();
|
|
} catch (e) {
|
|
console.warn("[SyncStorage] 清理过期操作失败:", e);
|
|
}
|
|
}
|
|
function D(e, t) {
|
|
let n = {};
|
|
if (e.nodeCreate || t.nodeCreate) {
|
|
let o = new Map();
|
|
for (let n of [...(e.nodeCreate || []), ...(t.nodeCreate || [])])
|
|
o.set(n.id, n);
|
|
n.nodeCreate = Array.from(o.values());
|
|
}
|
|
if (e.nodeUpdate || t.nodeUpdate) {
|
|
let o = new Map();
|
|
for (let n of [...(e.nodeUpdate || []), ...(t.nodeUpdate || [])])
|
|
o.set(n.id, n);
|
|
n.nodeUpdate = Array.from(o.values());
|
|
}
|
|
if (
|
|
((e.nodeDelete || t.nodeDelete) &&
|
|
(n.nodeDelete = Array.from(
|
|
new Set([...(e.nodeDelete || []), ...(t.nodeDelete || [])]),
|
|
)),
|
|
e.edgeCreate || t.edgeCreate)
|
|
) {
|
|
let o = new Map();
|
|
for (let n of [...(e.edgeCreate || []), ...(t.edgeCreate || [])])
|
|
o.set(n.id, n);
|
|
n.edgeCreate = Array.from(o.values());
|
|
}
|
|
if (e.edgeUpdate || t.edgeUpdate) {
|
|
let o = new Map();
|
|
for (let n of [...(e.edgeUpdate || []), ...(t.edgeUpdate || [])])
|
|
o.set(n.id, n);
|
|
n.edgeUpdate = Array.from(o.values());
|
|
}
|
|
return (
|
|
(e.edgeDelete || t.edgeDelete) &&
|
|
(n.edgeDelete = Array.from(
|
|
new Set([...(e.edgeDelete || []), ...(t.edgeDelete || [])]),
|
|
)),
|
|
n
|
|
);
|
|
}
|
|
function L(e) {
|
|
return (
|
|
!e.nodeCreate?.length &&
|
|
!e.nodeUpdate?.length &&
|
|
!e.nodeDelete?.length &&
|
|
!e.edgeCreate?.length &&
|
|
!e.edgeUpdate?.length &&
|
|
!e.edgeDelete?.length
|
|
);
|
|
}
|
|
class j {
|
|
pendingOp = {};
|
|
mergeTimer = null;
|
|
isFlushing = !1;
|
|
hasQueuedAfterFlush = !1;
|
|
retryCount = 0;
|
|
_status = "saved";
|
|
statusListeners = new Set();
|
|
projectUuid = null;
|
|
convertNodeFn;
|
|
convertEdgeFn;
|
|
getStateFn;
|
|
isOffline = !1;
|
|
handleOnline = null;
|
|
handleOffline = null;
|
|
_paused = !1;
|
|
_sessionExpiredCallback = null;
|
|
_localVersion = 0;
|
|
_serverVersion = 0;
|
|
_conflictResolver = null;
|
|
lastFlushFailureMessage = null;
|
|
lastFlushFailureCode = null;
|
|
constructor(e, t, n) {
|
|
(this.convertNodeFn = e),
|
|
(this.convertEdgeFn = t),
|
|
(this.getStateFn = n),
|
|
(this.isOffline = !navigator.onLine),
|
|
(this.handleOnline = () => {
|
|
(this.isOffline = !1), this.replayPersistedOps();
|
|
}),
|
|
(this.handleOffline = () => {
|
|
this.isOffline = !0;
|
|
}),
|
|
window.addEventListener("online", this.handleOnline),
|
|
window.addEventListener("offline", this.handleOffline),
|
|
A();
|
|
}
|
|
setProjectId(e) {
|
|
(this.projectUuid = e), e && this.replayPersistedOps();
|
|
}
|
|
get status() {
|
|
return this._status;
|
|
}
|
|
getLastFlushFailureMessage() {
|
|
return this.lastFlushFailureMessage;
|
|
}
|
|
getLastFlushFailureCode() {
|
|
return this.lastFlushFailureCode;
|
|
}
|
|
clearLastFlushFailureMessage() {
|
|
(this.lastFlushFailureMessage = null),
|
|
(this.lastFlushFailureCode = null);
|
|
}
|
|
get localVersion() {
|
|
return this._localVersion;
|
|
}
|
|
get serverVersion() {
|
|
return this._serverVersion;
|
|
}
|
|
setServerVersion(e) {
|
|
(this._serverVersion = e), (this._localVersion = e);
|
|
}
|
|
onConflict(e) {
|
|
return (
|
|
(this._conflictResolver = e),
|
|
() => {
|
|
this._conflictResolver = null;
|
|
}
|
|
);
|
|
}
|
|
onSessionExpired(e) {
|
|
return (
|
|
(this._sessionExpiredCallback = e),
|
|
() => {
|
|
this._sessionExpiredCallback = null;
|
|
}
|
|
);
|
|
}
|
|
pause() {
|
|
(this._paused = !0),
|
|
this.mergeTimer &&
|
|
(clearTimeout(this.mergeTimer), (this.mergeTimer = null));
|
|
}
|
|
resume() {
|
|
(this._paused = !1),
|
|
L(this.pendingOp) ||
|
|
this.isFlushing ||
|
|
(this.setStatus("pending"),
|
|
(this.mergeTimer = setTimeout(() => {
|
|
(this.mergeTimer = null), this.flush();
|
|
}, 500)));
|
|
}
|
|
enqueue(e) {
|
|
if (!this.projectUuid || L(e)) return;
|
|
if (this._paused) {
|
|
let t = JSON.parse(JSON.stringify(e));
|
|
this.pendingOp = D(this.pendingOp, t);
|
|
return;
|
|
}
|
|
let t = JSON.parse(JSON.stringify(e));
|
|
if (
|
|
((this.pendingOp = D(this.pendingOp, t)),
|
|
this.setStatus("pending"),
|
|
this.isOffline)
|
|
)
|
|
return void k(this.projectUuid, t);
|
|
if (this.isFlushing) {
|
|
this.hasQueuedAfterFlush = !0;
|
|
return;
|
|
}
|
|
this.mergeTimer && clearTimeout(this.mergeTimer),
|
|
(this.mergeTimer = setTimeout(() => {
|
|
(this.mergeTimer = null), this.flush();
|
|
}, 500));
|
|
}
|
|
onStatusChange(e) {
|
|
return (
|
|
this.statusListeners.add(e),
|
|
() => {
|
|
this.statusListeners.delete(e);
|
|
}
|
|
);
|
|
}
|
|
retry() {
|
|
"error" === this._status &&
|
|
((this.retryCount = 0), this.setStatus("pending"), this.flush());
|
|
}
|
|
requestImmediateFlush() {
|
|
this.mergeTimer &&
|
|
(clearTimeout(this.mergeTimer), (this.mergeTimer = null)),
|
|
L(this.pendingOp) || this.isFlushing || this._paused || this.flush();
|
|
}
|
|
flushAndWait() {
|
|
return this._paused
|
|
? Promise.resolve({ ok: !1 })
|
|
: (this.mergeTimer &&
|
|
(clearTimeout(this.mergeTimer), (this.mergeTimer = null)),
|
|
L(this.pendingOp) && !this.isFlushing)
|
|
? Promise.resolve({ ok: !0 })
|
|
: (L(this.pendingOp) ||
|
|
this.isFlushing ||
|
|
this._paused ||
|
|
this.flush(),
|
|
new Promise((e) => {
|
|
if (!this.isFlushing && L(this.pendingOp))
|
|
return void e({ ok: "saved" === this._status });
|
|
let t = this.onStatusChange((n) => {
|
|
("saved" === n || "error" === n) &&
|
|
(t(), e({ ok: "saved" === n }));
|
|
});
|
|
}));
|
|
}
|
|
flushSync() {
|
|
if (
|
|
(this.mergeTimer &&
|
|
(clearTimeout(this.mergeTimer), (this.mergeTimer = null)),
|
|
!this._paused) &&
|
|
!(!this.projectUuid || L(this.pendingOp))
|
|
)
|
|
try {
|
|
let e = this.buildPayload();
|
|
if (((this.pendingOp = {}), e)) {
|
|
let t = (0, y.getActiveSession)(),
|
|
n = t
|
|
? { ...e, sessionId: t.sessionId, timestamp: t.timestamp }
|
|
: e,
|
|
o = JSON.stringify(n),
|
|
i = `${b.config.tv.apiHost}/api/canvas/nodes/batch`,
|
|
r = I.getUsertokenFromCookie?.() ?? "";
|
|
try {
|
|
fetch(i, {
|
|
method: "POST",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
...(r ? { token: r } : {}),
|
|
},
|
|
body: o,
|
|
keepalive: !0,
|
|
}).catch(() => {});
|
|
} catch {
|
|
let e = new Blob([o], { type: "application/json" });
|
|
navigator.sendBeacon(i, e);
|
|
}
|
|
}
|
|
} catch {}
|
|
}
|
|
async replayPersistedOps() {
|
|
if (this.projectUuid && !this.isOffline)
|
|
try {
|
|
let e = await T(this.projectUuid);
|
|
if (0 === e.length) return;
|
|
for (let t of e) this.pendingOp = D(this.pendingOp, t);
|
|
await O(this.projectUuid),
|
|
L(this.pendingOp) ||
|
|
this.isFlushing ||
|
|
(this.setStatus("pending"), this.flush());
|
|
} catch {}
|
|
}
|
|
setStatus(e) {
|
|
this._status !== e &&
|
|
((this._status = e),
|
|
this.statusListeners.forEach((t) => {
|
|
try {
|
|
t(e);
|
|
} catch {}
|
|
}));
|
|
}
|
|
buildPayload() {
|
|
if (!this.projectUuid || L(this.pendingOp)) return null;
|
|
let e = this.projectUuid,
|
|
t = (function (e) {
|
|
let t = { ...e };
|
|
if (t.nodeCreate?.length && t.nodeDelete?.length) {
|
|
let e = new Set(t.nodeDelete),
|
|
n = t.nodeCreate.filter((t) => !e.has(t.id)),
|
|
o = t.nodeCreate.filter((t) => e.has(t.id)).map((e) => e.id);
|
|
(t.nodeCreate = n.length ? n : void 0),
|
|
(t.nodeDelete = t.nodeDelete.filter((e) => !o.includes(e))),
|
|
t.nodeDelete.length || (t.nodeDelete = void 0);
|
|
}
|
|
if (t.nodeCreate?.length && t.nodeUpdate?.length) {
|
|
let e = new Map(t.nodeCreate.map((e) => [e.id, e])),
|
|
n = [];
|
|
for (let o of t.nodeUpdate) {
|
|
let t = e.get(o.id);
|
|
t && (Object.assign(t.data ?? {}, o.data ?? {}), n.push(o.id));
|
|
}
|
|
if (n.length) {
|
|
let e = new Set(n);
|
|
(t.nodeUpdate = t.nodeUpdate.filter((t) => !e.has(t.id))),
|
|
t.nodeUpdate.length || (t.nodeUpdate = void 0);
|
|
}
|
|
}
|
|
if (t.nodeUpdate?.length && t.nodeDelete?.length) {
|
|
let e = new Set(t.nodeDelete);
|
|
(t.nodeUpdate = t.nodeUpdate.filter((t) => !e.has(t.id))),
|
|
t.nodeUpdate.length || (t.nodeUpdate = void 0);
|
|
}
|
|
if (t.edgeCreate?.length && t.edgeDelete?.length) {
|
|
let e = new Set(t.edgeDelete),
|
|
n = t.edgeCreate.filter((t) => !e.has(t.id)),
|
|
o = t.edgeCreate.filter((t) => e.has(t.id)).map((e) => e.id);
|
|
(t.edgeCreate = n.length ? n : void 0),
|
|
(t.edgeDelete = t.edgeDelete.filter((e) => !o.includes(e))),
|
|
t.edgeDelete.length || (t.edgeDelete = void 0);
|
|
}
|
|
if (t.edgeCreate?.length && t.edgeUpdate?.length) {
|
|
let e = new Map(t.edgeCreate.map((e) => [e.id, e])),
|
|
n = [];
|
|
for (let o of t.edgeUpdate) {
|
|
let t = e.get(o.id);
|
|
t && (Object.assign(t, o), n.push(o.id));
|
|
}
|
|
if (n.length) {
|
|
let e = new Set(n);
|
|
(t.edgeUpdate = t.edgeUpdate.filter((t) => !e.has(t.id))),
|
|
t.edgeUpdate.length || (t.edgeUpdate = void 0);
|
|
}
|
|
}
|
|
if (t.edgeUpdate?.length && t.edgeDelete?.length) {
|
|
let e = new Set(t.edgeDelete);
|
|
(t.edgeUpdate = t.edgeUpdate.filter((t) => !e.has(t.id))),
|
|
t.edgeUpdate.length || (t.edgeUpdate = void 0);
|
|
}
|
|
return t;
|
|
})(this.pendingOp),
|
|
{ nodes: n, edges: o } = this.getStateFn(),
|
|
i = new Set(n.map((e) => e.id)),
|
|
r = t.nodeDelete ? new Set(t.nodeDelete) : new Set(),
|
|
a = {},
|
|
s = {};
|
|
return (t.nodeCreate?.length &&
|
|
(a.create = t.nodeCreate.map((t) => this.convertNodeFn(t, e, i, r))),
|
|
t.nodeUpdate?.length &&
|
|
(a.update = t.nodeUpdate.map((t) => this.convertNodeFn(t, e, i, r))),
|
|
t.nodeDelete?.length &&
|
|
(a.delete = t.nodeDelete.map((t) => {
|
|
let o = n.find((e) => e.id === t);
|
|
return o
|
|
? this.convertNodeFn(o, e, i, r)
|
|
: { nodeKey: t, projectUuid: e };
|
|
})),
|
|
t.edgeCreate?.length &&
|
|
(s.create = t.edgeCreate.map((t) => this.convertEdgeFn(t, e))),
|
|
t.edgeUpdate?.length &&
|
|
(s.update = t.edgeUpdate.map((t) => this.convertEdgeFn(t, e))),
|
|
t.edgeDelete?.length &&
|
|
(s.delete = t.edgeDelete.map((t) => {
|
|
let n = o.find((e) => e.id === t);
|
|
return n
|
|
? this.convertEdgeFn(n, e)
|
|
: { projectUuid: e, connectionId: t, source: "", target: "" };
|
|
})),
|
|
a.create || a.update || a.delete || s.create || s.update || s.delete)
|
|
? {
|
|
projectUuid: e,
|
|
nodes: a,
|
|
connections: s,
|
|
version: this._localVersion,
|
|
}
|
|
: null;
|
|
}
|
|
async flush() {
|
|
if (this.isFlushing || this._paused) return;
|
|
let e = this.buildPayload();
|
|
if (!e) return void this.setStatus("saved");
|
|
let t = { ...this.pendingOp };
|
|
(this.pendingOp = {}),
|
|
(this.isFlushing = !0),
|
|
(this.hasQueuedAfterFlush = !1),
|
|
this.setStatus("syncing");
|
|
let n = C().startMeasure("sync.flush");
|
|
try {
|
|
(this.lastFlushFailureMessage = null),
|
|
(this.lastFlushFailureCode = null),
|
|
await (0, y.nodesBatch)(e),
|
|
n({ success: !0 }),
|
|
this._localVersion++,
|
|
(this._serverVersion = this._localVersion),
|
|
(this.retryCount = 0),
|
|
(this.isFlushing = !1),
|
|
(this.hasQueuedAfterFlush = !1),
|
|
L(this.pendingOp)
|
|
? this.setStatus("saved")
|
|
: (this.mergeTimer = setTimeout(() => {
|
|
(this.mergeTimer = null), this.flush();
|
|
}, 500));
|
|
} catch (o) {
|
|
(this.isFlushing = !1), n({ success: !1 });
|
|
let e = (function (e) {
|
|
if (null == e) return;
|
|
if ("string" == typeof e) return e.trim() || void 0;
|
|
if ("object" != typeof e) return;
|
|
if ("string" == typeof e.message && e.message.trim())
|
|
return e.message.trim();
|
|
if ("string" == typeof e.msg && e.msg.trim()) return e.msg.trim();
|
|
let t = e.response;
|
|
if (t && "object" == typeof t) {
|
|
let e = t.data;
|
|
if (e && "object" == typeof e) {
|
|
let t = e.msg ?? e.message;
|
|
if ("string" == typeof t && t.trim()) return t.trim();
|
|
}
|
|
}
|
|
})(o);
|
|
if (
|
|
(e && (this.lastFlushFailureMessage = e),
|
|
(this.lastFlushFailureCode =
|
|
(function (e) {
|
|
if (null == e || "object" != typeof e) return;
|
|
if (void 0 !== e.code) return e.code;
|
|
let t = e.response;
|
|
if (t && "object" == typeof t) {
|
|
if (t.data && "object" == typeof t.data) {
|
|
let e = t.data.code;
|
|
if (void 0 !== e) return e;
|
|
}
|
|
if ("number" == typeof t.status) return t.status;
|
|
}
|
|
})(o) ?? null),
|
|
(0, y.isSessionExpiredError)(o))
|
|
) {
|
|
(this.pendingOp = D(t, this.pendingOp)),
|
|
this.setStatus("error"),
|
|
this.pause(),
|
|
this._sessionExpiredCallback?.();
|
|
return;
|
|
}
|
|
if (
|
|
((this.pendingOp = D(t, this.pendingOp)), this.isVersionConflict(o))
|
|
) {
|
|
if ((this.setStatus("conflict"), this._conflictResolver))
|
|
try {
|
|
let e = this.extractServerVersion(o);
|
|
await this._conflictResolver(e),
|
|
(this.retryCount = 0),
|
|
L(this.pendingOp)
|
|
? this.setStatus("saved")
|
|
: (this.setStatus("pending"), this.flush());
|
|
} catch {
|
|
this.setStatus("error");
|
|
}
|
|
else this.setStatus("error");
|
|
return;
|
|
}
|
|
if ((this.retryCount++, this.retryCount <= 3)) {
|
|
let e = 1e3 * Math.pow(2, this.retryCount - 1);
|
|
this.setStatus("pending"),
|
|
setTimeout(() => {
|
|
this.flush();
|
|
}, e);
|
|
} else
|
|
this.projectUuid &&
|
|
!L(this.pendingOp) &&
|
|
k(this.projectUuid, this.pendingOp),
|
|
this.setStatus("error");
|
|
}
|
|
}
|
|
isVersionConflict(e) {
|
|
if (e && "object" == typeof e) {
|
|
if (e.response && "object" == typeof e.response) {
|
|
let t = e.response;
|
|
if (409 === t.status) return !0;
|
|
if (t.data && "object" == typeof t.data) {
|
|
let e = t.data;
|
|
if ("VERSION_CONFLICT" === e.code || 409 === e.code) return !0;
|
|
}
|
|
}
|
|
if ("VERSION_CONFLICT" === e.code || 409 === e.status) return !0;
|
|
}
|
|
return !1;
|
|
}
|
|
extractServerVersion(e) {
|
|
if (
|
|
e &&
|
|
"object" == typeof e &&
|
|
e.response &&
|
|
"object" == typeof e.response
|
|
) {
|
|
let t = e.response;
|
|
if (t.data && "object" == typeof t.data) {
|
|
let e = t.data;
|
|
if ("number" == typeof e.version) return e.version;
|
|
if ("number" == typeof e.serverVersion) return e.serverVersion;
|
|
}
|
|
}
|
|
return this._serverVersion;
|
|
}
|
|
destroy() {
|
|
this.mergeTimer &&
|
|
(clearTimeout(this.mergeTimer), (this.mergeTimer = null)),
|
|
this.handleOnline &&
|
|
window.removeEventListener("online", this.handleOnline),
|
|
this.handleOffline &&
|
|
window.removeEventListener("offline", this.handleOffline),
|
|
this.statusListeners.clear(),
|
|
(this._conflictResolver = null),
|
|
(this._sessionExpiredCallback = null),
|
|
(this._paused = !1),
|
|
(this.isFlushing = !1),
|
|
(this.retryCount = 0),
|
|
(this.pendingOp = {}),
|
|
(this.lastFlushFailureMessage = null),
|
|
(this.lastFlushFailureCode = null);
|
|
}
|
|
}
|
|
let R = g.NODE_GAP / 2;
|
|
function z(e) {
|
|
return {
|
|
x: e.position.x,
|
|
y: e.position.y,
|
|
width: e.measured?.width ?? e.width ?? g.NODE_WIDTH,
|
|
height: e.measured?.height ?? e.height ?? g.NODE_HEIGHT_EMPTY,
|
|
};
|
|
}
|
|
function F(e, t, n) {
|
|
return (
|
|
e.x < t.x + t.width + n &&
|
|
e.x + e.width + n > t.x &&
|
|
e.y < t.y + t.height + n &&
|
|
e.y + e.height + n > t.y
|
|
);
|
|
}
|
|
function $(e, t, n, o) {
|
|
return "x" === o
|
|
? Math.min(
|
|
Math.abs(t.x + t.width + n - e.x),
|
|
Math.abs(e.x + e.width + n - t.x),
|
|
)
|
|
: Math.min(
|
|
Math.abs(t.y + t.height + n - e.y),
|
|
Math.abs(e.y + e.height + n - t.y),
|
|
);
|
|
}
|
|
function B(
|
|
e,
|
|
t = { width: g.NODE_WIDTH, height: g.NODE_HEIGHT_EMPTY },
|
|
n,
|
|
o = {},
|
|
) {
|
|
let {
|
|
preferAxis: i = "vertical",
|
|
margin: r = R,
|
|
maxIterations: a = 30,
|
|
excludeIds: s,
|
|
} = o,
|
|
l = n.filter((e) => !s?.has(e.id)).map((e) => z(e)),
|
|
{ x: d, y: u } = e;
|
|
for (let e = 0; e < a; e++) {
|
|
let e = { x: d, y: u, width: t.width, height: t.height },
|
|
n = 0;
|
|
for (let t of l)
|
|
F(e, t, r) &&
|
|
(n = Math.max(
|
|
n,
|
|
"vertical" === i
|
|
? $(e, t, r, "y")
|
|
: "horizontal" === i
|
|
? $(e, t, r, "x")
|
|
: Math.max($(e, t, r, "x"), $(e, t, r, "y")),
|
|
));
|
|
if (0 === n) break;
|
|
"vertical" === i
|
|
? (u += n)
|
|
: "horizontal" === i
|
|
? (d += n)
|
|
: ((d += n), (u += n));
|
|
}
|
|
return { x: d, y: u };
|
|
}
|
|
function H(
|
|
e,
|
|
t = { width: g.NODE_WIDTH, height: g.NODE_HEIGHT_EMPTY },
|
|
n,
|
|
o = {},
|
|
) {
|
|
let i = o.margin ?? R,
|
|
r = o.maxIterations ?? 30,
|
|
a = o.excludeIds,
|
|
s = n.filter((e) => !a?.has(e.id)).map((e) => z(e)),
|
|
l = e.x,
|
|
d = e.y;
|
|
for (let e = 0; e < r; e++) {
|
|
let e = { x: l, y: d, width: t.width, height: t.height },
|
|
n = d,
|
|
o = !1;
|
|
for (let t of s)
|
|
F(e, t, i) && ((o = !0), (n = Math.max(n, t.y + t.height + i)));
|
|
if (!o) break;
|
|
d = n;
|
|
}
|
|
return { x: l, y: d };
|
|
}
|
|
function V(e, t, n, o, i, r, a = g.NODE_GAP) {
|
|
let s = e.x + t + a,
|
|
l = e.y,
|
|
d = new Set(i.filter((e) => e.source === r).map((e) => e.target)),
|
|
u = o.filter((n) => !!d.has(n.id) && n.position.x >= e.x + t / 2);
|
|
return 0 === u.length
|
|
? { x: s, y: l }
|
|
: {
|
|
x: s,
|
|
y:
|
|
Math.max(
|
|
...u.map((e) => {
|
|
let t = e.measured?.height ?? e.height ?? g.NODE_HEIGHT_EMPTY;
|
|
return e.position.y + t;
|
|
}),
|
|
) + a,
|
|
};
|
|
}
|
|
function U(e, t, n = {}) {
|
|
let o = t.filter((e) => !n.excludeIds?.has(e.id)).map((e) => z(e)),
|
|
i = [];
|
|
for (let { position: t, size: r } of e) {
|
|
let e = B(
|
|
t,
|
|
r,
|
|
o.map((e, t) => ({
|
|
id: `__virtual_${t}`,
|
|
position: { x: e.x, y: e.y },
|
|
measured: { width: e.width, height: e.height },
|
|
})),
|
|
{ ...n, excludeIds: void 0 },
|
|
);
|
|
i.push(e), o.push({ x: e.x, y: e.y, width: r.width, height: r.height });
|
|
}
|
|
return i;
|
|
}
|
|
function Y(e) {
|
|
let t = e.measured?.width ?? e.width,
|
|
n = e.measured?.height ?? e.height;
|
|
if ("number" == typeof t && "number" == typeof n)
|
|
return { width: t, height: n };
|
|
let o = e.data,
|
|
i = o?.contentWidth,
|
|
r = o?.contentHeight;
|
|
if ("number" == typeof i && "number" == typeof r)
|
|
return { width: i, height: r };
|
|
let a = (0, g.extractRatioFromNodeParams)(o?.params),
|
|
s = (0, g.computeNodeDimensionsFromRatio)(a);
|
|
return a
|
|
? s
|
|
: {
|
|
width:
|
|
("number" == typeof t ? t : void 0) ?? s.width ?? g.NODE_WIDTH,
|
|
height:
|
|
("number" == typeof n ? n : void 0) ??
|
|
s.height ??
|
|
g.NODE_HEIGHT_EMPTY,
|
|
};
|
|
}
|
|
function W(e, t) {
|
|
let n = new Map(t.map((e) => [e.id, e])),
|
|
o = e.position.x,
|
|
i = e.position.y,
|
|
r = e.parentId;
|
|
for (; r; ) {
|
|
let e = n.get(r);
|
|
if (!e) break;
|
|
(o += e.position.x), (i += e.position.y), (r = e.parentId);
|
|
}
|
|
return { x: o, y: i };
|
|
}
|
|
function X(e) {
|
|
let t = e.data?.contentWidth,
|
|
n = "number" == typeof t ? t : void 0;
|
|
if ("number" == typeof n && n > 0) return n;
|
|
let o = "number" == typeof e.measured?.width ? e.measured.width : void 0,
|
|
i = "number" == typeof e.width ? e.width : void 0;
|
|
return o ?? i ?? g.NODE_WIDTH;
|
|
}
|
|
function K(
|
|
e,
|
|
t,
|
|
n = { width: g.NODE_WIDTH, height: g.NODE_HEIGHT_EMPTY },
|
|
o = 120,
|
|
) {
|
|
let i,
|
|
r = W(e, t),
|
|
a = X(e),
|
|
s = r.x + a + o,
|
|
l = g.NODE_GAP / 2,
|
|
d = t.map((e) => {
|
|
let n = W(e, t);
|
|
return {
|
|
x: n.x,
|
|
y: n.y,
|
|
width: X(e),
|
|
height: e.measured?.height ?? e.height ?? g.NODE_HEIGHT_EMPTY,
|
|
};
|
|
});
|
|
if (
|
|
((i = r.y),
|
|
!d.some(
|
|
(e) =>
|
|
s < e.x + e.width + l &&
|
|
s + n.width + l > e.x &&
|
|
i < e.y + e.height + l &&
|
|
i + n.height + l > e.y,
|
|
))
|
|
)
|
|
return { x: s, y: r.y };
|
|
let u = (e) => {
|
|
let t = d.filter(
|
|
(t) => e < t.x + t.width + l && e + n.width + l > t.x,
|
|
);
|
|
if (0 === t.length) return r.y;
|
|
let o = t
|
|
.map((e) => ({
|
|
top: e.y - n.height - l,
|
|
bottom: e.y + e.height + l,
|
|
}))
|
|
.sort((e, t) => e.top - t.top),
|
|
i = [];
|
|
for (let e of o)
|
|
i.length > 0 && e.top <= i[i.length - 1].bottom
|
|
? (i[i.length - 1].bottom = Math.max(
|
|
i[i.length - 1].bottom,
|
|
e.bottom,
|
|
))
|
|
: i.push({ top: e.top, bottom: e.bottom });
|
|
let a = r.y,
|
|
s = a,
|
|
u = 1 / 0,
|
|
c = (e) => {
|
|
let t = Math.abs(e - a);
|
|
t < u && ((u = t), (s = e));
|
|
};
|
|
c(Math.min(a, i[0].top));
|
|
for (let e = 0; e < i.length - 1; e++) {
|
|
let t = i[e].bottom,
|
|
n = i[e + 1].top;
|
|
n - t < 1 || c(Math.max(t, Math.min(a, n)));
|
|
}
|
|
return c(Math.max(a, i[i.length - 1].bottom)), s;
|
|
},
|
|
c = new Set();
|
|
for (let e of (c.add(s), d)) {
|
|
let t = e.x + e.width + l,
|
|
o = e.x - n.width - l;
|
|
t >= s && c.add(t), o >= s && c.add(o);
|
|
}
|
|
let p = s,
|
|
h = r.y,
|
|
f = 1 / 0;
|
|
for (let e of c) {
|
|
let t = u(e),
|
|
n = e - s,
|
|
o = t - r.y,
|
|
i = n * n + o * o;
|
|
i < f && ((f = i), (p = e), (h = t));
|
|
}
|
|
return { x: p, y: h };
|
|
}
|
|
e.s(
|
|
[
|
|
"CANVAS_RIGHT_EDGE_GAP",
|
|
0,
|
|
120,
|
|
"findClosestRightFlowPosition",
|
|
() => K,
|
|
"findRightSidePosition",
|
|
() => V,
|
|
"getAbsoluteNodePosition",
|
|
() => W,
|
|
"getNodeSizeForPlacement",
|
|
() => Y,
|
|
"resolveMultiNodePlacement",
|
|
() => U,
|
|
"resolveNodePlacement",
|
|
() => B,
|
|
"resolveNodePlacementDagBelowOccluders",
|
|
() => H,
|
|
],
|
|
44980,
|
|
);
|
|
class q {
|
|
bySource = new Map();
|
|
byTarget = new Map();
|
|
lastEdgesRef = null;
|
|
rebuild(e) {
|
|
if (e !== this.lastEdgesRef)
|
|
for (let t of ((this.lastEdgesRef = e),
|
|
this.bySource.clear(),
|
|
this.byTarget.clear(),
|
|
e)) {
|
|
let e = this.bySource.get(t.source);
|
|
e ? e.push(t) : this.bySource.set(t.source, [t]);
|
|
let n = this.byTarget.get(t.target);
|
|
n ? n.push(t) : this.byTarget.set(t.target, [t]);
|
|
}
|
|
}
|
|
getBySource(e) {
|
|
return this.bySource.get(e) ?? [];
|
|
}
|
|
getByTarget(e) {
|
|
return this.byTarget.get(e) ?? [];
|
|
}
|
|
getByNode(e) {
|
|
return [...this.getBySource(e), ...this.getByTarget(e)];
|
|
}
|
|
}
|
|
let Z = new q();
|
|
class G {
|
|
byId = new Map();
|
|
lastNodesRef = null;
|
|
rebuild(e) {
|
|
if (e !== this.lastNodesRef)
|
|
for (let t of ((this.lastNodesRef = e), this.byId.clear(), e))
|
|
this.byId.set(t.id, t);
|
|
}
|
|
get(e) {
|
|
return this.byId.get(e);
|
|
}
|
|
}
|
|
let Q = new G();
|
|
class J {
|
|
byNodeId = new Map();
|
|
byUrl = new Map();
|
|
byTaskId = new Map();
|
|
lastNodesRef = null;
|
|
rebuild(e) {
|
|
if (e !== this.lastNodesRef)
|
|
for (let t of ((this.lastNodesRef = e),
|
|
this.byNodeId.clear(),
|
|
this.byUrl.clear(),
|
|
this.byTaskId.clear(),
|
|
e)) {
|
|
let e = t.resourceMeta;
|
|
if (!e) continue;
|
|
this.byNodeId.set(t.id, e);
|
|
let n = Array.isArray(e.items) ? e.items : [],
|
|
o = t.data ?? void 0,
|
|
i = Array.isArray(o?.url) ? o.url : [];
|
|
for (let [e, o] of n.entries()) {
|
|
let n = i[e];
|
|
n && this.byUrl.set(n, { nodeId: t.id, item: o });
|
|
}
|
|
let r = o?.taskInfo,
|
|
a = r?.taskId ?? "";
|
|
if (a) {
|
|
let e = this.byTaskId.get(a) ?? [];
|
|
n.forEach((n) => e.push({ nodeId: t.id, item: n })),
|
|
this.byTaskId.set(a, e);
|
|
}
|
|
}
|
|
}
|
|
getByNodeId(e) {
|
|
return this.byNodeId.get(e);
|
|
}
|
|
getByUrl(e) {
|
|
return this.byUrl.get(e);
|
|
}
|
|
getByTaskId(e) {
|
|
return this.byTaskId.get(e) ?? [];
|
|
}
|
|
}
|
|
let ee = new J(),
|
|
et = "__temp_connection_node__";
|
|
function en(e) {
|
|
return e.id === et || "temp" === e.type || "temp" === e.data?.type;
|
|
}
|
|
function eo(e) {
|
|
return (
|
|
"__temp_connection_edge__" === e.id ||
|
|
e.source === et ||
|
|
e.target === et
|
|
);
|
|
}
|
|
function ei(e) {
|
|
return (t) => (Z.rebuild(t.edges), Z.getByTarget(e).length > 0);
|
|
}
|
|
function er(e) {
|
|
return (t) => (Z.rebuild(t.edges), Z.getBySource(e).length > 0);
|
|
}
|
|
function ea(e) {
|
|
return (t) => {
|
|
Q.rebuild(t.nodes);
|
|
let n = Q.get(e);
|
|
return n?.data ?? null;
|
|
};
|
|
}
|
|
function es(e, t) {
|
|
return (n) =>
|
|
!!e &&
|
|
(Z.rebuild(n.edges),
|
|
!!Z.getBySource(e).some((e) => e.target === t) ||
|
|
Z.getBySource(t).some((t) => t.target === e));
|
|
}
|
|
function el(e, t) {
|
|
return (n) => {
|
|
if (0 === e.length) return !1;
|
|
for (let o of e) if (es(o, t)(n)) return !0;
|
|
return !1;
|
|
};
|
|
}
|
|
function ed(e) {
|
|
return (t) => (ee.rebuild(t.nodes), ee.getByNodeId(e) ?? null);
|
|
}
|
|
function eu(e) {
|
|
return (t) => (ee.rebuild(t.nodes), ee.getByUrl(e) ?? null);
|
|
}
|
|
function ec(e) {
|
|
return (t) => (ee.rebuild(t.nodes), ee.getByTaskId(e));
|
|
}
|
|
function ep(e = "id") {
|
|
return "u" > typeof crypto && "function" == typeof crypto.randomUUID
|
|
? `${e}-${crypto.randomUUID()}`
|
|
: `${e}-${Date.now()}-${Math.random().toString(36).slice(2, 11)}-${Math.random().toString(36).slice(2, 11)}`;
|
|
}
|
|
function eh(e) {
|
|
if (null == e || "object" != typeof e) return e;
|
|
if (e instanceof Date) return new Date(e.getTime());
|
|
if (Array.isArray(e)) return e.map((e) => eh(e));
|
|
try {
|
|
return JSON.parse(JSON.stringify(e));
|
|
} catch {
|
|
let t = {};
|
|
for (let n in e)
|
|
Object.prototype.hasOwnProperty.call(e, n) && (t[n] = eh(e[n]));
|
|
return t;
|
|
}
|
|
}
|
|
function eg(e) {
|
|
let t = { ...e },
|
|
n = "string" == typeof t.name ? t.name : void 0,
|
|
o = "string" == typeof t.label ? t.label : void 0;
|
|
return !n && o && (t.name = o), "label" in t && delete t.label, t;
|
|
}
|
|
function ef(e) {
|
|
return e
|
|
? {
|
|
[y.NodeType.TEXT]: m.NodeType.TEXT,
|
|
[y.NodeType.IMAGE]: m.NodeType.IMAGE,
|
|
[y.NodeType.VIDEO]: m.NodeType.VIDEO,
|
|
[y.NodeType.AUDIO]: m.NodeType.AUDIO,
|
|
[y.NodeType.GROUP]: m.NodeType.GROUP,
|
|
[y.NodeType.SCRIPT]: m.NodeType.SCRIPT,
|
|
[y.NodeType.VIDEO_CLIP]: m.NodeType.VIDEO_CLIP,
|
|
[y.NodeType.SPACE_SCENE_720]: m.NodeType.SPACE_SCENE_720,
|
|
}[e]
|
|
: m.NodeType.TEXT;
|
|
}
|
|
function em(e) {
|
|
return e.startsWith("blob:") || e.startsWith("data:");
|
|
}
|
|
function ey(e, t, n, o) {
|
|
var i;
|
|
let r = eg(e.data ?? {}),
|
|
a =
|
|
"number" == typeof (i = r?.type)
|
|
? i
|
|
: {
|
|
[m.NodeType.TEXT]: y.NodeType.TEXT,
|
|
[m.NodeType.IMAGE]: y.NodeType.IMAGE,
|
|
[m.NodeType.VIDEO]: y.NodeType.VIDEO,
|
|
[m.NodeType.AUDIO]: y.NodeType.AUDIO,
|
|
[m.NodeType.GROUP]: y.NodeType.GROUP,
|
|
[m.NodeType.VIDEO_CLIP]: y.NodeType.VIDEO_CLIP,
|
|
[m.NodeType.SPACE_SCENE_720]: y.NodeType.SPACE_SCENE_720,
|
|
}[i] || y.NodeType.TEXT,
|
|
s = e.parentId || null;
|
|
s &&
|
|
(o && o.has(s)
|
|
? (console.warn(
|
|
`[convertNode] 清除 parentKey: node=${e.id} parent=${s}（父节点正在被删除）`,
|
|
),
|
|
(s = null))
|
|
: n &&
|
|
!n.has(s) &&
|
|
(console.warn(
|
|
`[convertNode] 清除 parentKey: node=${e.id} parent=${s}（父节点不存在于画布中）`,
|
|
),
|
|
(s = null)));
|
|
let l = s ?? "";
|
|
if (l && "" !== l) {
|
|
let t = n?.has(l),
|
|
i = o?.has(l);
|
|
console.debug(
|
|
`[convertNode] 发送非空 parentKey: node=${e.id} parentKey=${l}`,
|
|
`| parentExists=${t} parentDeleting=${i}`,
|
|
`| nodeType=${a} existingCount=${n?.size ?? "?"} deletedCount=${o?.size ?? "?"}`,
|
|
);
|
|
}
|
|
let d = (function (e) {
|
|
let t = { ...e };
|
|
if (Array.isArray(t.url)) {
|
|
let e = t.url.map((e) => ("string" == typeof e && em(e) ? "" : e));
|
|
e.some((e) => "" === e) && (t.url = e.filter((e) => "" !== e));
|
|
}
|
|
return (
|
|
"string" == typeof t.poster && em(t.poster) && (t.poster = ""),
|
|
"string" == typeof t.panoramaUrl &&
|
|
em(t.panoramaUrl) &&
|
|
(t.panoramaUrl = ""),
|
|
t
|
|
);
|
|
})(r),
|
|
u = e.resourceMeta;
|
|
return (
|
|
u && (d._resourceMeta = u),
|
|
{
|
|
nodeKey: e.id,
|
|
projectUuid: t,
|
|
type: a,
|
|
name: d?.name,
|
|
position: {
|
|
positionX: String(e.position.x),
|
|
positionY: String(e.position.y),
|
|
},
|
|
measured: e.measured
|
|
? {
|
|
width: String(e.measured.width),
|
|
height: String(e.measured.height),
|
|
}
|
|
: void 0,
|
|
parentKey: l,
|
|
data: JSON.stringify(d),
|
|
workflowUuid: d?.workflowUuid || void 0,
|
|
}
|
|
);
|
|
}
|
|
function ev(e, t) {
|
|
return {
|
|
projectUuid: t,
|
|
connectionId: e.id,
|
|
source: e.source,
|
|
target: e.target,
|
|
sourceHandle: e.sourceHandle || void 0,
|
|
targetHandle: e.targetHandle || void 0,
|
|
type: e.type || "default",
|
|
deletable: !1 !== e.deletable,
|
|
selectable: !1 !== e.selectable,
|
|
};
|
|
}
|
|
function ew(e, t, n) {}
|
|
let ex = { zoom: 1, position: { x: 0, y: 0 } };
|
|
function eS(e, t, n) {
|
|
let o = e.find((e) => e.id === n);
|
|
if (!o?.data) return;
|
|
let i = o.data;
|
|
if (!i.params) return;
|
|
let r = t.filter((e) => {
|
|
if (e.target !== n) return !1;
|
|
let t = e.data;
|
|
return !t?.portraitVirtual && !t?.assetVirtual;
|
|
}),
|
|
a = new Map(e.map((e) => [e.id, e])),
|
|
s = r.map((e) => a.get(e.source)).filter((e) => !!e),
|
|
l = (0, p.collectIncomingNodeData)(s),
|
|
d = i.scriptRowHiddenUuid;
|
|
if (d) {
|
|
let t = (0, p.findHiddenLineImageNode)(d, e, n);
|
|
t && l.imageList.push(t);
|
|
}
|
|
let u = i.params,
|
|
c = (0, f.normalizeMediaList)(u.imageList).filter(
|
|
(e) => e.nodeId && (0, f.isAssetProtocol)(e.nodeId),
|
|
),
|
|
g = [...l.imageList, ...c],
|
|
m = (0, f.normalizeMediaList)(u.videoList).filter(
|
|
(e) => e.nodeId && (0, f.isAssetProtocol)(e.nodeId),
|
|
),
|
|
y = [...l.videoList, ...m],
|
|
v = (0, f.normalizeMediaList)(u.audioList).filter(
|
|
(e) => e.nodeId && (0, f.isAssetProtocol)(e.nodeId),
|
|
),
|
|
w = [...l.audioList, ...v],
|
|
x = u.imageListOrder,
|
|
S = u.videoListOrder,
|
|
b = u.audioListOrder,
|
|
I = (0, h.applyMediaListOrder)(g, x),
|
|
_ = (0, h.applyMediaListOrder)(y, S),
|
|
E = (0, h.applyMediaListOrder)(w, b),
|
|
M = (function (e, t, n) {
|
|
if (!e) return e;
|
|
let o = t.imageList ?? [],
|
|
i = t.videoList ?? [],
|
|
r = t.audioList ?? [],
|
|
a = t.mixedListOrder ?? void 0,
|
|
s = (0, h.buildMixedList)(o, i, r, a),
|
|
l = (0, h.buildMixedList)(n.imageList, n.videoList, n.audioList, a),
|
|
d = {
|
|
Image: new Map(n.imageList.map((e, t) => [e.nodeId, t + 1])),
|
|
Video: new Map(n.videoList.map((e, t) => [e.nodeId, t + 1])),
|
|
Audio: new Map(n.audioList.map((e, t) => [e.nodeId, t + 1])),
|
|
Mixed: new Map(l.map((e, t) => [e.nodeId, t + 1])),
|
|
Portrait: new Map(n.imageList.map((e, t) => [e.nodeId, t + 1])),
|
|
},
|
|
u = { Image: o, Video: i, Audio: r, Mixed: s, Portrait: o };
|
|
return e
|
|
.replace(
|
|
/(\n[ \t]*)?\{\{(Image|Video|Audio|Mixed|Portrait)\s+(\d+)\}\}[ \t]*/g,
|
|
(e, t, n, o) => {
|
|
let i = parseInt(o, 10) - 1,
|
|
r = u[n],
|
|
a = r?.[i];
|
|
if (!a?.nodeId) return "";
|
|
let s = d[n]?.get(a.nodeId);
|
|
return void 0 === s ? "" : `${t ?? ""}{{${n} ${s}}} `;
|
|
},
|
|
)
|
|
.replace(/ {2,}/g, " ")
|
|
.trim();
|
|
})("string" == typeof u.prompt ? u.prompt : "", u, {
|
|
imageList: I,
|
|
videoList: _,
|
|
audioList: E,
|
|
});
|
|
o.data = {
|
|
...o.data,
|
|
params: {
|
|
...u,
|
|
prompt: M,
|
|
textList: l.textList,
|
|
imageList: I,
|
|
videoList: _,
|
|
audioList: E,
|
|
},
|
|
};
|
|
}
|
|
function eb(e, t) {
|
|
let n = t.data?.type;
|
|
if (n && !t.data?.name) {
|
|
let o = (0, m.resolveCanvasNodeTypeLabelZh)(n) ?? n,
|
|
i = e.filter((e) => e.data?.type === n).length;
|
|
t.data.name = `${o}${i + 1}`;
|
|
}
|
|
}
|
|
let eI = () => {
|
|
let e = null,
|
|
t = new Set();
|
|
function n() {
|
|
if ((e && (clearTimeout(e), (e = null)), 0 === t.size || !o)) return;
|
|
let n = o.getState().nodes.filter((e) => t.has(e.id));
|
|
t.clear(), n.length > 0 && i.enqueue({ nodeUpdate: n });
|
|
}
|
|
let o = null,
|
|
i = new j(ey, ev, () => {
|
|
if (!o) return { nodes: [], edges: [] };
|
|
let e = o.getState();
|
|
return { nodes: eh(e.nodes), edges: eh(e.edges) };
|
|
}),
|
|
r = new Set(),
|
|
a = (e) => {
|
|
for (let t of r)
|
|
try {
|
|
t(e);
|
|
} catch (e) {
|
|
console.error("[CanvasStore] onSendToChat listener error", e);
|
|
}
|
|
},
|
|
s = (0, c.createStore)()(
|
|
(0, d.devtools)(
|
|
(0, u.immer)(
|
|
(s, d) => (
|
|
i.onStatusChange((e) => {
|
|
s((t) => {
|
|
(t.syncStatus = e), (t.syncVersion = i.localVersion);
|
|
});
|
|
}),
|
|
{
|
|
nodes: [],
|
|
edges: [],
|
|
viewport: { ...ex },
|
|
projectId: null,
|
|
projectName: "未命名",
|
|
projectTemplateUuid: null,
|
|
isLoadingProject: !1,
|
|
isRestoring: !1,
|
|
syncStatus: "saved",
|
|
isMarkMode: !1,
|
|
markSourceNodeId: null,
|
|
isFocusMode: !1,
|
|
focusSourceNodeId: null,
|
|
focusInteractingNodeId: null,
|
|
focusCancelKey: 0,
|
|
isCanvasCaptureMode: !1,
|
|
canvasCaptureCallback: null,
|
|
syncVersion: 0,
|
|
connectingSourceId: null,
|
|
connectingSourceIds: null,
|
|
multiSelectHoveredNodeId: null,
|
|
multiSelectCursorPos: null,
|
|
connectingInvalidTargetId: null,
|
|
editingNodeId: null,
|
|
editingImageTool: null,
|
|
panoramaPreviewNodeIds: new Set(),
|
|
editingClipNodeId: null,
|
|
editingClipPreviewExpanded: !0,
|
|
editingClipNodeFocusNonce: 0,
|
|
deletingNodeIds: new Set(),
|
|
canvasLocked: !1,
|
|
isReadonly: !1,
|
|
snapToGrid: (() => {
|
|
try {
|
|
let e = localStorage.getItem("canvas:snapToGrid");
|
|
return null === e || "true" === e;
|
|
} catch {
|
|
return !0;
|
|
}
|
|
})(),
|
|
isBoxSelecting: !1,
|
|
isInteracting: !1,
|
|
pendingFocusNodeIds: null,
|
|
imageEditorPrimaryToolbarTool: "upscale",
|
|
applyNodeChanges: (e) => {
|
|
s((t) => {
|
|
t.nodes = (0, l.applyNodeChanges)(e, t.nodes);
|
|
});
|
|
let t = d();
|
|
S(e, t.editingClipNodeId, t.editingClipPreviewExpanded);
|
|
},
|
|
applyEdgeChanges: (e) => {
|
|
s((t) => {
|
|
t.edges = (0, l.applyEdgeChanges)(e, t.edges);
|
|
});
|
|
},
|
|
addNode: (e, t) => {
|
|
if (
|
|
(e.data &&
|
|
"object" == typeof e.data &&
|
|
(e.data = eg(e.data)),
|
|
eb(d().nodes, e),
|
|
!t?.skipOverlapResolution && !e.parentId)
|
|
) {
|
|
let n = {
|
|
width: e.measured?.width ?? e.width ?? g.NODE_WIDTH,
|
|
height:
|
|
e.measured?.height ?? e.height ?? g.NODE_HEIGHT_EMPTY,
|
|
};
|
|
e.position = B(e.position, n, d().nodes, t);
|
|
}
|
|
return (
|
|
s((t) => {
|
|
e.parentId ? t.nodes.push(e) : t.nodes.unshift(e),
|
|
ew(
|
|
{
|
|
nodes: t.nodes,
|
|
edges: t.edges,
|
|
viewport: t.viewport,
|
|
},
|
|
"添加节点",
|
|
t.projectId,
|
|
),
|
|
en(e) || i.enqueue({ nodeCreate: [e] });
|
|
}),
|
|
e.id
|
|
);
|
|
},
|
|
addNodes: (e, t) => {
|
|
let n = d().nodes;
|
|
if (
|
|
(e.forEach((e) => {
|
|
e.data &&
|
|
"object" == typeof e.data &&
|
|
(e.data = eg(e.data)),
|
|
eb(n, e);
|
|
}),
|
|
!t?.skipOverlapResolution)
|
|
) {
|
|
let o = e.filter((e) => !e.parentId);
|
|
if (o.length > 0) {
|
|
let e = U(
|
|
o.map((e) => ({
|
|
position: e.position,
|
|
size: {
|
|
width:
|
|
e.measured?.width ?? e.width ?? g.NODE_WIDTH,
|
|
height:
|
|
e.measured?.height ??
|
|
e.height ??
|
|
g.NODE_HEIGHT_EMPTY,
|
|
},
|
|
})),
|
|
n,
|
|
t,
|
|
);
|
|
o.forEach((t, n) => {
|
|
t.position = e[n];
|
|
});
|
|
}
|
|
}
|
|
return (
|
|
s((n) => {
|
|
let o = e.filter((e) => !e.parentId),
|
|
r = e.filter((e) => e.parentId);
|
|
if (
|
|
(n.nodes.unshift(...o),
|
|
n.nodes.push(...r),
|
|
ew(
|
|
{
|
|
nodes: n.nodes,
|
|
edges: n.edges,
|
|
viewport: n.viewport,
|
|
},
|
|
"批量添加节点",
|
|
n.projectId,
|
|
),
|
|
!t?.skipSync)
|
|
) {
|
|
let t = e.filter((e) => !en(e));
|
|
t.length > 0 && i.enqueue({ nodeCreate: t });
|
|
}
|
|
}),
|
|
e.map((e) => e.id)
|
|
);
|
|
},
|
|
clearPendingFocusNodeIds: () => {
|
|
s((e) => {
|
|
e.pendingFocusNodeIds = null;
|
|
});
|
|
},
|
|
requestFitViewToNodeIds: (e) => {
|
|
let t = e.filter(
|
|
(e) => "string" == typeof e && e.trim().length > 0,
|
|
);
|
|
0 !== t.length &&
|
|
s((e) => {
|
|
e.pendingFocusNodeIds = t;
|
|
});
|
|
},
|
|
deleteNode: (e) => {
|
|
s((t) => {
|
|
t.deletingNodeIds = new Set([e]);
|
|
let n = t.edges.filter(
|
|
(t) => t.source === e || t.target === e,
|
|
),
|
|
o = n.map((e) => e.id),
|
|
r = new Set(
|
|
n.filter((t) => t.source === e).map((e) => e.target),
|
|
),
|
|
a = t.nodes.find((t) => t.id === e);
|
|
for (let n of ((t.nodes = t.nodes.filter(
|
|
(t) => t.id !== e,
|
|
)),
|
|
(t.edges = t.edges.filter(
|
|
(t) => t.source !== e && t.target !== e,
|
|
)),
|
|
t.editingClipNodeId === e && (t.editingClipNodeId = null),
|
|
t.panoramaPreviewNodeIds.delete(e),
|
|
t.nodes))
|
|
n.parentId === e &&
|
|
(a &&
|
|
(n.position = {
|
|
x: a.position.x + n.position.x,
|
|
y: a.position.y + n.position.y,
|
|
}),
|
|
(n.parentId = void 0),
|
|
(n.extent = void 0));
|
|
for (let e of r) {
|
|
eS(t.nodes, t.edges, e);
|
|
let n = t.nodes.find((t) => t.id === e);
|
|
n?.data?.isStale &&
|
|
(n.data = { ...n.data, isStale: !1 });
|
|
}
|
|
ew(
|
|
{
|
|
nodes: t.nodes,
|
|
edges: t.edges,
|
|
viewport: t.viewport,
|
|
},
|
|
"删除节点",
|
|
t.projectId,
|
|
),
|
|
i.enqueue({
|
|
nodeDelete: [e],
|
|
edgeDelete: o.length > 0 ? o : void 0,
|
|
});
|
|
}),
|
|
queueMicrotask(() => {
|
|
s((e) => {
|
|
e.deletingNodeIds = new Set();
|
|
});
|
|
});
|
|
},
|
|
deleteNodes: (e, t) => {
|
|
s((n) => {
|
|
n.deletingNodeIds = new Set(e);
|
|
let o = new Set(e),
|
|
r = n.edges.filter(
|
|
(e) => o.has(e.source) || o.has(e.target),
|
|
),
|
|
a = r.map((e) => e.id),
|
|
s = new Set(
|
|
r
|
|
.filter((e) => o.has(e.source) && !o.has(e.target))
|
|
.map((e) => e.target),
|
|
),
|
|
l = new Map(
|
|
n.nodes
|
|
.filter((e) => o.has(e.id))
|
|
.map((e) => [e.id, e]),
|
|
);
|
|
for (let e of ((n.nodes = n.nodes.filter(
|
|
(e) => !o.has(e.id),
|
|
)),
|
|
(n.edges = n.edges.filter(
|
|
(e) => !o.has(e.source) && !o.has(e.target),
|
|
)),
|
|
n.editingClipNodeId &&
|
|
o.has(n.editingClipNodeId) &&
|
|
(n.editingClipNodeId = null),
|
|
o))
|
|
n.panoramaPreviewNodeIds.delete(e);
|
|
for (let e of n.nodes)
|
|
if (e.parentId && o.has(e.parentId)) {
|
|
let t = l.get(e.parentId);
|
|
t &&
|
|
(e.position = {
|
|
x: t.position.x + e.position.x,
|
|
y: t.position.y + e.position.y,
|
|
}),
|
|
(e.parentId = void 0),
|
|
(e.extent = void 0);
|
|
}
|
|
for (let e of s) {
|
|
eS(n.nodes, n.edges, e);
|
|
let t = n.nodes.find((t) => t.id === e);
|
|
t?.data?.isStale &&
|
|
(t.data = { ...t.data, isStale: !1 });
|
|
}
|
|
ew(
|
|
{
|
|
nodes: n.nodes,
|
|
edges: n.edges,
|
|
viewport: n.viewport,
|
|
},
|
|
"批量删除节点",
|
|
n.projectId,
|
|
),
|
|
t?.skipSync ||
|
|
i.enqueue({
|
|
nodeDelete: e,
|
|
edgeDelete: a.length > 0 ? a : void 0,
|
|
});
|
|
}),
|
|
queueMicrotask(() => {
|
|
s((e) => {
|
|
e.deletingNodeIds = new Set();
|
|
});
|
|
});
|
|
},
|
|
updateNode: (e, t) => {
|
|
s((n) => {
|
|
let o = n.nodes.find((t) => t.id === e);
|
|
if (o) {
|
|
if (t.data && "object" == typeof t.data) {
|
|
o.data = eg({ ...(o.data ?? {}), ...t.data });
|
|
let { data: e, ...n } = t;
|
|
Object.assign(o, n);
|
|
} else Object.assign(o, t);
|
|
"parentId" in t &&
|
|
n.nodes.sort((e, t) =>
|
|
!e.parentId && t.parentId
|
|
? -1
|
|
: e.parentId && !t.parentId
|
|
? 1
|
|
: 0,
|
|
),
|
|
ew(
|
|
{
|
|
nodes: n.nodes,
|
|
edges: n.edges,
|
|
viewport: n.viewport,
|
|
},
|
|
"更新节点",
|
|
n.projectId,
|
|
),
|
|
i.enqueue({ nodeUpdate: [o] });
|
|
}
|
|
});
|
|
},
|
|
updateNodeData: (n, o, r) => {
|
|
let { resourceMeta: a, ...l } = o ?? {},
|
|
u = eg(l);
|
|
s((e) => {
|
|
let t = e.nodes.find((e) => e.id === n);
|
|
if (t) {
|
|
let n = u.taskInfo;
|
|
if (n?.loading === !0 && n.taskId) {
|
|
let e = t.data ?? {},
|
|
o = e.taskInfo;
|
|
if (o?.taskId && o.taskId !== n.taskId && !o.loading)
|
|
u.prevTaskInfo = e.taskInfo;
|
|
else if (o?.loading) {
|
|
let t = e.prevTaskInfo;
|
|
t && (u.prevTaskInfo = t);
|
|
}
|
|
}
|
|
(t.data = eg({ ...(t.data ?? {}), ...u })),
|
|
void 0 !== a && (t.resourceMeta = a),
|
|
ew(
|
|
{
|
|
nodes: e.nodes,
|
|
edges: e.edges,
|
|
viewport: e.viewport,
|
|
},
|
|
"更新节点数据",
|
|
e.projectId,
|
|
);
|
|
}
|
|
}),
|
|
r?.skipSync ||
|
|
(t.add(n),
|
|
e && clearTimeout(e),
|
|
(e = setTimeout(() => {
|
|
let n = d().nodes.filter((e) => t.has(e.id));
|
|
t.clear(),
|
|
(e = null),
|
|
n.length > 0 && i.enqueue({ nodeUpdate: n });
|
|
}, 300)));
|
|
},
|
|
batchUpdateNodeData: (n) => {
|
|
let o = new Set();
|
|
if (
|
|
(s((e) => {
|
|
for (let { nodeId: t, data: i, skipSync: r } of n) {
|
|
let { resourceMeta: n, ...a } = i ?? {},
|
|
s = eg(a),
|
|
l = e.nodes.find((e) => e.id === t);
|
|
if (!l) continue;
|
|
let d = s.taskInfo;
|
|
if (d?.loading === !0 && d.taskId) {
|
|
let e = l.data ?? {},
|
|
t = e.taskInfo;
|
|
if (
|
|
t?.taskId &&
|
|
t.taskId !== d.taskId &&
|
|
!t.loading
|
|
)
|
|
s.prevTaskInfo = e.taskInfo;
|
|
else if (t?.loading) {
|
|
let t = e.prevTaskInfo;
|
|
t && (s.prevTaskInfo = t);
|
|
}
|
|
}
|
|
(l.data = eg({ ...(l.data ?? {}), ...s })),
|
|
void 0 !== n && (l.resourceMeta = n),
|
|
r || o.add(t);
|
|
}
|
|
ew(
|
|
{
|
|
nodes: e.nodes,
|
|
edges: e.edges,
|
|
viewport: e.viewport,
|
|
},
|
|
"批量更新节点数据",
|
|
e.projectId,
|
|
);
|
|
}),
|
|
o.size > 0)
|
|
) {
|
|
for (let e of o) t.add(e);
|
|
e && clearTimeout(e),
|
|
(e = setTimeout(() => {
|
|
let n = d().nodes.filter((e) => t.has(e.id));
|
|
t.clear(),
|
|
(e = null),
|
|
n.length > 0 && i.enqueue({ nodeUpdate: n });
|
|
}, 300));
|
|
}
|
|
},
|
|
updateNodes: (e, t) => {
|
|
s((n) => {
|
|
let o = [],
|
|
r = !1;
|
|
e.forEach(({ id: e, updates: t }) => {
|
|
let i = n.nodes.find((t) => t.id === e);
|
|
i &&
|
|
("parentId" in t && (r = !0),
|
|
Object.assign(i, t),
|
|
o.push(i));
|
|
}),
|
|
r &&
|
|
n.nodes.sort((e, t) =>
|
|
!e.parentId && t.parentId
|
|
? -1
|
|
: e.parentId && !t.parentId
|
|
? 1
|
|
: 0,
|
|
),
|
|
ew(
|
|
{
|
|
nodes: n.nodes,
|
|
edges: n.edges,
|
|
viewport: n.viewport,
|
|
},
|
|
"批量更新节点",
|
|
n.projectId,
|
|
),
|
|
!t?.skipSync &&
|
|
o.length > 0 &&
|
|
i.enqueue({ nodeUpdate: o });
|
|
});
|
|
},
|
|
getNode: (e) => d().nodes.find((t) => t.id === e),
|
|
getNodes: () => d().nodes,
|
|
setNodes: (n) => {
|
|
e && (clearTimeout(e), (e = null)),
|
|
t.clear(),
|
|
s((e) => {
|
|
let t = new Set(e.nodes.map((e) => e.id)),
|
|
o = [],
|
|
r = [];
|
|
n.forEach((e) => {
|
|
t.has(e.id) ? r.push(e) : o.push(e);
|
|
});
|
|
let a = new Set(n.map((e) => e.id)),
|
|
s = e.nodes
|
|
.filter((e) => !a.has(e.id))
|
|
.map((e) => e.id),
|
|
l = new Set(s),
|
|
d = n.map((e) => {
|
|
let t =
|
|
e.data && "object" == typeof e.data
|
|
? eg(e.data)
|
|
: e.data;
|
|
return e.parentId &&
|
|
(l.has(e.parentId) || !a.has(e.parentId))
|
|
? {
|
|
...e,
|
|
data: t,
|
|
parentId: void 0,
|
|
extent: void 0,
|
|
}
|
|
: { ...e, data: t };
|
|
}),
|
|
u = r.map((e) =>
|
|
e.parentId &&
|
|
(l.has(e.parentId) || !a.has(e.parentId))
|
|
? { ...e, parentId: void 0, extent: void 0 }
|
|
: e,
|
|
);
|
|
d.sort((e, t) =>
|
|
!e.parentId && t.parentId
|
|
? -1
|
|
: e.parentId && !t.parentId
|
|
? 1
|
|
: 0,
|
|
),
|
|
(e.nodes = d),
|
|
ew(
|
|
{
|
|
nodes: e.nodes,
|
|
edges: e.edges,
|
|
viewport: e.viewport,
|
|
},
|
|
"设置节点",
|
|
e.projectId,
|
|
),
|
|
e.isLoadingProject ||
|
|
e.isRestoring ||
|
|
i.enqueue({
|
|
nodeCreate: o.length > 0 ? o : void 0,
|
|
nodeUpdate: u.length > 0 ? u : void 0,
|
|
nodeDelete: s.length > 0 ? s : void 0,
|
|
});
|
|
});
|
|
},
|
|
addEdge: (e) => {
|
|
let t = { ...e, id: e.id || ep("edge") };
|
|
return (
|
|
s((e) => {
|
|
e.edges.push(t),
|
|
t.target && eS(e.nodes, e.edges, t.target),
|
|
ew(
|
|
{
|
|
nodes: e.nodes,
|
|
edges: e.edges,
|
|
viewport: e.viewport,
|
|
},
|
|
"添加边",
|
|
e.projectId,
|
|
),
|
|
eo(t) || i.enqueue({ edgeCreate: [t] });
|
|
}),
|
|
t.id
|
|
);
|
|
},
|
|
addEdges: (e, t) => {
|
|
let n = e.map((e) => ({ ...e, id: e.id || ep("edge") }));
|
|
return 0 === n.length
|
|
? []
|
|
: (s((e) => {
|
|
for (let t of n) e.edges.push(t);
|
|
for (let t of new Set(n.map((e) => e.target)))
|
|
eS(e.nodes, e.edges, t);
|
|
if (
|
|
(ew(
|
|
{
|
|
nodes: e.nodes,
|
|
edges: e.edges,
|
|
viewport: e.viewport,
|
|
},
|
|
"批量添加边",
|
|
e.projectId,
|
|
),
|
|
!t?.skipSync)
|
|
) {
|
|
let e = n.filter((e) => !eo(e));
|
|
e.length > 0 && i.enqueue({ edgeCreate: e });
|
|
}
|
|
}),
|
|
n.map((e) => e.id));
|
|
},
|
|
deleteEdge: (e) => {
|
|
s((t) => {
|
|
let n = t.edges.find((t) => t.id === e);
|
|
(t.edges = t.edges.filter((t) => t.id !== e)),
|
|
n && eS(t.nodes, t.edges, n.target),
|
|
ew(
|
|
{
|
|
nodes: t.nodes,
|
|
edges: t.edges,
|
|
viewport: t.viewport,
|
|
},
|
|
"删除边",
|
|
t.projectId,
|
|
),
|
|
i.enqueue({ edgeDelete: [e] });
|
|
});
|
|
},
|
|
deleteEdges: (e, t) => {
|
|
s((n) => {
|
|
let o = new Set(e),
|
|
r = new Set(
|
|
n.edges
|
|
.filter((e) => o.has(e.id))
|
|
.map((e) => e.target),
|
|
);
|
|
for (let e of ((n.edges = n.edges.filter(
|
|
(e) => !o.has(e.id),
|
|
)),
|
|
r))
|
|
eS(n.nodes, n.edges, e);
|
|
ew(
|
|
{
|
|
nodes: n.nodes,
|
|
edges: n.edges,
|
|
viewport: n.viewport,
|
|
},
|
|
"批量删除边",
|
|
n.projectId,
|
|
),
|
|
t?.skipSync || i.enqueue({ edgeDelete: e });
|
|
});
|
|
},
|
|
updateEdge: (e, t) => {
|
|
s((n) => {
|
|
let o = n.edges.find((t) => t.id === e);
|
|
o &&
|
|
(Object.assign(o, t),
|
|
ew(
|
|
{
|
|
nodes: n.nodes,
|
|
edges: n.edges,
|
|
viewport: n.viewport,
|
|
},
|
|
"更新边",
|
|
n.projectId,
|
|
),
|
|
i.enqueue({ edgeUpdate: [o] }));
|
|
});
|
|
},
|
|
getEdge: (e) => d().edges.find((t) => t.id === e),
|
|
getEdges: () => d().edges,
|
|
getNodeEdges: (e) => {
|
|
let t = d().edges;
|
|
return Z.rebuild(t), Z.getByNode(e);
|
|
},
|
|
setEdges: (e) => {
|
|
s((t) => {
|
|
let n = new Set(t.edges.map((e) => e.id)),
|
|
o = [],
|
|
r = [];
|
|
e.forEach((e) => {
|
|
n.has(e.id) ? r.push(e) : o.push(e);
|
|
});
|
|
let a = new Set(e.map((e) => e.id)),
|
|
s = t.edges
|
|
.filter((e) => !a.has(e.id))
|
|
.map((e) => e.id);
|
|
(t.edges = e),
|
|
ew(
|
|
{
|
|
nodes: t.nodes,
|
|
edges: t.edges,
|
|
viewport: t.viewport,
|
|
},
|
|
"设置边",
|
|
t.projectId,
|
|
),
|
|
t.isLoadingProject ||
|
|
t.isRestoring ||
|
|
i.enqueue({
|
|
edgeCreate: o.length > 0 ? o : void 0,
|
|
edgeUpdate: r.length > 0 ? r : void 0,
|
|
edgeDelete: s.length > 0 ? s : void 0,
|
|
});
|
|
});
|
|
},
|
|
updateEdges: (e, t) => {
|
|
0 !== e.length &&
|
|
s((n) => {
|
|
let o = [],
|
|
r = new Set();
|
|
for (let t of (e.forEach(({ id: e, updates: t }) => {
|
|
let i = n.edges.find((t) => t.id === e);
|
|
if (!i) return;
|
|
let a = i.target;
|
|
Object.assign(i, t),
|
|
r.add(i.target),
|
|
a !== i.target && r.add(a),
|
|
o.push(i);
|
|
}),
|
|
r))
|
|
eS(n.nodes, n.edges, t);
|
|
if (
|
|
(ew(
|
|
{
|
|
nodes: n.nodes,
|
|
edges: n.edges,
|
|
viewport: n.viewport,
|
|
},
|
|
"批量更新边",
|
|
n.projectId,
|
|
),
|
|
!t?.skipSync && o.length > 0)
|
|
) {
|
|
let e = o.filter((e) => !eo(e));
|
|
e.length > 0 && i.enqueue({ edgeUpdate: e });
|
|
}
|
|
});
|
|
},
|
|
getIncomingNodes: (e) => {
|
|
let t = d();
|
|
Z.rebuild(t.edges);
|
|
let n = Z.getByTarget(e),
|
|
o = new Map(t.nodes.map((e) => [e.id, e]));
|
|
return n
|
|
.filter((e) => {
|
|
let t = e.data;
|
|
return !t?.portraitVirtual && !t?.assetVirtual;
|
|
})
|
|
.map((e) => o.get(e.source))
|
|
.filter((e) => !!e);
|
|
},
|
|
getOutgoingNodes: (e) => {
|
|
let t = d();
|
|
Z.rebuild(t.edges);
|
|
let n = new Set(Z.getBySource(e).map((e) => e.target));
|
|
return t.nodes.filter((e) => n.has(e.id));
|
|
},
|
|
markDownstreamStale: (e) => {
|
|
let t = [];
|
|
if (
|
|
(s((n) => {
|
|
for (let o of (Z.rebuild(n.edges), Z.getBySource(e))) {
|
|
let e = n.nodes.find((e) => e.id === o.target);
|
|
if (e) {
|
|
let n = e.data.taskInfo;
|
|
if (!n?.loading) {
|
|
let n = e.data.staleVersion || 0;
|
|
(e.data = {
|
|
...e.data,
|
|
isStale: !0,
|
|
staleVersion: n + 1,
|
|
}),
|
|
t.push(e.id);
|
|
}
|
|
}
|
|
}
|
|
}),
|
|
t.length > 0)
|
|
) {
|
|
let e = d().nodes.filter((e) => t.includes(e.id));
|
|
e.length > 0 && i.enqueue({ nodeUpdate: e });
|
|
}
|
|
},
|
|
setZoom: (e) => {
|
|
s((t) => {
|
|
(t.viewport.zoom = e),
|
|
ew(
|
|
{
|
|
nodes: t.nodes,
|
|
edges: t.edges,
|
|
viewport: t.viewport,
|
|
},
|
|
"设置缩放",
|
|
t.projectId,
|
|
);
|
|
});
|
|
},
|
|
setViewport: (e) => {
|
|
s((t) => {
|
|
void 0 !== e.zoom && (t.viewport.zoom = e.zoom),
|
|
e.position &&
|
|
(t.viewport.position = {
|
|
...t.viewport.position,
|
|
...e.position,
|
|
}),
|
|
ew(
|
|
{
|
|
nodes: t.nodes,
|
|
edges: t.edges,
|
|
viewport: t.viewport,
|
|
},
|
|
"设置视图",
|
|
t.projectId,
|
|
);
|
|
});
|
|
},
|
|
getViewport: () => d().viewport,
|
|
getState: () => eh(d()),
|
|
setState: (e) => {
|
|
s((t) => {
|
|
void 0 !== e.nodes && (t.nodes = e.nodes),
|
|
void 0 !== e.edges && (t.edges = e.edges),
|
|
void 0 !== e.viewport &&
|
|
(t.viewport = { ...e.viewport }),
|
|
ew(
|
|
{
|
|
nodes: t.nodes,
|
|
edges: t.edges,
|
|
viewport: t.viewport,
|
|
},
|
|
"设置状态",
|
|
t.projectId,
|
|
);
|
|
});
|
|
},
|
|
reset: () => {
|
|
s((e) => {
|
|
(e.nodes = []),
|
|
(e.edges = []),
|
|
(e.viewport = { ...ex }),
|
|
(e.projectTemplateUuid = null),
|
|
(e.isMarkMode = !1),
|
|
(e.markSourceNodeId = null),
|
|
(e.isFocusMode = !1),
|
|
(e.focusSourceNodeId = null),
|
|
(e.focusInteractingNodeId = null),
|
|
(e.focusCancelKey = 0),
|
|
(e.isReadonly = !1),
|
|
(e.editingNodeId = null),
|
|
(e.panoramaPreviewNodeIds = new Set()),
|
|
(e.editingClipNodeId = null),
|
|
(e.editingClipPreviewExpanded = !0),
|
|
(e.editingClipNodeFocusNonce = 0),
|
|
(e.canvasLocked = !1);
|
|
try {
|
|
let t = localStorage.getItem("canvas:snapToGrid");
|
|
e.snapToGrid = null === t || "true" === t;
|
|
} catch {
|
|
e.snapToGrid = !0;
|
|
}
|
|
(e.isBoxSelecting = !1),
|
|
(e.connectingSourceId = null),
|
|
(e.connectingSourceIds = null),
|
|
(e.multiSelectHoveredNodeId = null),
|
|
(e.multiSelectCursorPos = null),
|
|
(e.connectingInvalidTargetId = null),
|
|
(e.imageEditorPrimaryToolbarTool = "upscale"),
|
|
ew(
|
|
{
|
|
nodes: e.nodes,
|
|
edges: e.edges,
|
|
viewport: e.viewport,
|
|
},
|
|
"重置画布",
|
|
e.projectId,
|
|
);
|
|
});
|
|
},
|
|
clear: () => {
|
|
s((e) => {
|
|
(e.nodes = []),
|
|
(e.edges = []),
|
|
ew(
|
|
{
|
|
nodes: e.nodes,
|
|
edges: e.edges,
|
|
viewport: e.viewport,
|
|
},
|
|
"清空画布",
|
|
e.projectId,
|
|
);
|
|
});
|
|
},
|
|
export: () => d().getState(),
|
|
import: (e) => {
|
|
d().setState(e);
|
|
},
|
|
setProjectId: (e) => {
|
|
d().projectId !== e &&
|
|
(i.setProjectId(e),
|
|
s((t) => {
|
|
(t.projectId = e), (t.projectTemplateUuid = null);
|
|
}));
|
|
},
|
|
setProjectName: (e) => {
|
|
s((t) => {
|
|
t.projectName = e;
|
|
});
|
|
},
|
|
setProjectTemplateUuid: (e) => {
|
|
s((t) => {
|
|
t.projectTemplateUuid = e;
|
|
});
|
|
},
|
|
setLoadingProject: (e) => {
|
|
s((t) => {
|
|
t.isLoadingProject = e;
|
|
});
|
|
},
|
|
setRestoring: (e) => {
|
|
s((t) => {
|
|
t.isRestoring = e;
|
|
});
|
|
},
|
|
setMarkMode: (e, t) => {
|
|
s((n) => {
|
|
(n.isMarkMode = e),
|
|
(n.markSourceNodeId = e ? (t ?? null) : null),
|
|
e &&
|
|
((n.isFocusMode = !1),
|
|
(n.focusSourceNodeId = null),
|
|
(n.isCanvasCaptureMode = !1),
|
|
(n.canvasCaptureCallback = null));
|
|
});
|
|
},
|
|
setFocusMode: (e, t) => {
|
|
s((n) => {
|
|
(n.isFocusMode = e),
|
|
(n.focusSourceNodeId = e ? (t ?? null) : null),
|
|
e || (n.focusInteractingNodeId = null),
|
|
e &&
|
|
((n.isMarkMode = !1),
|
|
(n.markSourceNodeId = null),
|
|
(n.isCanvasCaptureMode = !1),
|
|
(n.canvasCaptureCallback = null));
|
|
});
|
|
},
|
|
setCanvasCaptureMode: (e, t) => {
|
|
s((n) => {
|
|
(n.isCanvasCaptureMode = e),
|
|
(n.canvasCaptureCallback = e ? (t ?? null) : null),
|
|
e &&
|
|
((n.isMarkMode = !1),
|
|
(n.markSourceNodeId = null),
|
|
(n.isFocusMode = !1),
|
|
(n.focusSourceNodeId = null),
|
|
(n.focusInteractingNodeId = null));
|
|
});
|
|
},
|
|
setFocusInteractingNode: (e) => {
|
|
s((t) => {
|
|
t.focusInteractingNodeId = e;
|
|
});
|
|
},
|
|
cancelFocusPendingRegion: () => {
|
|
s((e) => {
|
|
e.focusCancelKey += 1;
|
|
});
|
|
},
|
|
setConnectingSourceId: (e) => {
|
|
s((t) => {
|
|
(t.connectingSourceId = e),
|
|
(t.connectingSourceIds = null),
|
|
null === e && (t.connectingInvalidTargetId = null);
|
|
});
|
|
},
|
|
setConnectingSourceIds: (e) => {
|
|
s((t) => {
|
|
(t.connectingSourceIds = e),
|
|
e?.length && (t.connectingSourceId = null),
|
|
e?.length ||
|
|
((t.multiSelectHoveredNodeId = null),
|
|
(t.multiSelectCursorPos = null));
|
|
});
|
|
},
|
|
setMultiSelectHoveredNodeId: (e) => {
|
|
s((t) => {
|
|
t.multiSelectHoveredNodeId = e;
|
|
});
|
|
},
|
|
setMultiSelectCursorPos: (e) => {
|
|
s((t) => {
|
|
t.multiSelectCursorPos = e;
|
|
});
|
|
},
|
|
setConnectingInvalidTargetId: (e) => {
|
|
s((t) => {
|
|
t.connectingInvalidTargetId = e;
|
|
});
|
|
},
|
|
retrySyncQueue: () => {
|
|
i.retry();
|
|
},
|
|
flushSyncQueue: () => {
|
|
n(), i.flushSync();
|
|
},
|
|
requestImmediateFlush: () => {
|
|
n(), i.requestImmediateFlush();
|
|
},
|
|
waitForSyncSaved: (e = 6e4, t) => (
|
|
i.clearLastFlushFailureMessage(),
|
|
new Promise((r) => {
|
|
let a = !1,
|
|
s = null,
|
|
l = null,
|
|
d = (e) => {
|
|
a || ((a = !0), s && clearTimeout(s), l?.(), r(e));
|
|
};
|
|
if (
|
|
((l = i.onStatusChange((e) => {
|
|
if ("saved" === e) d({ ok: !0 });
|
|
else if ("error" === e) {
|
|
let e = i.getLastFlushFailureMessage()?.trim(),
|
|
t = i.getLastFlushFailureCode() ?? void 0;
|
|
d({
|
|
ok: !1,
|
|
...(e ? { msg: e } : {}),
|
|
...(void 0 !== t ? { code: t } : {}),
|
|
});
|
|
}
|
|
})),
|
|
n(),
|
|
t?.includeFullNodeEdgeSnapshot && o)
|
|
) {
|
|
let e = o.getState();
|
|
if (e.projectId) {
|
|
let t = e.nodes.filter((e) => !en(e)),
|
|
n = e.edges.filter((e) => !eo(e));
|
|
(t.length > 0 || n.length > 0) &&
|
|
i.enqueue({
|
|
...(t.length > 0 ? { nodeUpdate: eh(t) } : {}),
|
|
...(n.length > 0 ? { edgeUpdate: eh(n) } : {}),
|
|
});
|
|
}
|
|
}
|
|
i.requestImmediateFlush(),
|
|
queueMicrotask(() => {
|
|
"saved" === i.status && d({ ok: !0 });
|
|
}),
|
|
Number.isFinite(e) &&
|
|
e > 0 &&
|
|
(s = setTimeout(
|
|
() =>
|
|
d({
|
|
ok: !1,
|
|
code: "WAIT_TIMEOUT",
|
|
msg: "保存超时",
|
|
}),
|
|
e,
|
|
));
|
|
})
|
|
),
|
|
saveFullSnapshotAsUpdate: async () => {
|
|
if (!o) return { ok: !1, msg: "保存失败" };
|
|
let e = o.getState().projectId;
|
|
if (!e)
|
|
return {
|
|
ok: !1,
|
|
msg: "项目未加载",
|
|
code: "PROJECT_ID_MISSING",
|
|
};
|
|
if (
|
|
(n(),
|
|
i.clearLastFlushFailureMessage(),
|
|
!(await i.flushAndWait()).ok)
|
|
)
|
|
return {
|
|
ok: !1,
|
|
code: "INCREMENTAL_FLUSH_FAILED",
|
|
msg: "增量同步失败，手动保存已中止，请重试",
|
|
};
|
|
await Promise.resolve();
|
|
let t = o.getState(),
|
|
r = t.nodes.filter((e) => !en(e)),
|
|
a = t.edges.filter((e) => !eo(e));
|
|
if (0 === r.length && 0 === a.length) return { ok: !0 };
|
|
let s = new Set(r.map((e) => e.id)),
|
|
l = r.map((t) => ey(t, e, s, new Set())),
|
|
d = a.map((t) => ev(t, e));
|
|
try {
|
|
let t = {
|
|
projectUuid: e,
|
|
nodes: { update: l },
|
|
connections: { update: d },
|
|
version: i.localVersion,
|
|
};
|
|
return (
|
|
await (0, y.nodesBatch)(t),
|
|
i.setServerVersion(i.localVersion + 1),
|
|
{ ok: !0 }
|
|
);
|
|
} catch (n) {
|
|
let e = n.code ?? n.response?.data?.code,
|
|
t =
|
|
n.response?.data?.msg ??
|
|
n.response?.data?.message ??
|
|
n.message;
|
|
return {
|
|
ok: !1,
|
|
...(void 0 !== e ? { code: e } : {}),
|
|
...("string" == typeof t && t.trim()
|
|
? { msg: t.trim() }
|
|
: {}),
|
|
};
|
|
}
|
|
},
|
|
enqueueSyncOp: (e) => {
|
|
i.enqueue(e);
|
|
},
|
|
pauseSyncQueue: () => {
|
|
i.pause();
|
|
},
|
|
resumeSyncQueue: () => {
|
|
i.resume();
|
|
},
|
|
onSyncSessionExpired: (e) => i.onSessionExpired(e),
|
|
sendToChat: (e) => {
|
|
if ("batch" === e.type) {
|
|
let e = d()
|
|
.nodes.filter((e) => e.selected && !en(e))
|
|
.map((e) => e.id);
|
|
if (0 === e.length) return;
|
|
a({ type: "batch", nodeIds: e });
|
|
return;
|
|
}
|
|
"single" === e.type && a(e);
|
|
},
|
|
onSendToChat: (e) => (
|
|
r.add(e),
|
|
() => {
|
|
r.delete(e);
|
|
}
|
|
),
|
|
setSyncServerVersion: (e) => {
|
|
i.setServerVersion(e),
|
|
s((t) => {
|
|
t.syncVersion = e;
|
|
});
|
|
},
|
|
setEditingNodeId: (e) => {
|
|
s((t) => {
|
|
(t.editingNodeId = e), e || (t.editingImageTool = null);
|
|
});
|
|
},
|
|
setPanoramaPreviewNodeId: (e) => {
|
|
s((t) => {
|
|
null === e
|
|
? (t.panoramaPreviewNodeIds = new Set())
|
|
: t.panoramaPreviewNodeIds.add(e);
|
|
});
|
|
},
|
|
removePanoramaPreviewNodeId: (e) => {
|
|
s((t) => {
|
|
t.panoramaPreviewNodeIds.delete(e);
|
|
});
|
|
},
|
|
setEditingImageTool: (e) => {
|
|
s((t) => {
|
|
t.editingImageTool = e;
|
|
});
|
|
},
|
|
setImageEditorPrimaryToolbarTool: (e) => {
|
|
s((t) => {
|
|
t.imageEditorPrimaryToolbarTool = e;
|
|
});
|
|
},
|
|
setEditingClipNodeId: (e) => {
|
|
s((t) => {
|
|
(t.editingClipNodeId = e),
|
|
null === e && (t.editingClipPreviewExpanded = !0);
|
|
});
|
|
},
|
|
setEditingClipPreviewExpanded: (e) => {
|
|
s((t) => {
|
|
t.editingClipPreviewExpanded = e;
|
|
});
|
|
},
|
|
requestEditingClipNodeFocus: () => {
|
|
s((e) => {
|
|
e.editingClipNodeId && (e.editingClipNodeFocusNonce += 1);
|
|
});
|
|
},
|
|
setCanvasLocked: (e) => {
|
|
s((t) => {
|
|
t.canvasLocked = e;
|
|
});
|
|
},
|
|
setSnapToGrid: (e) => {
|
|
s((t) => {
|
|
t.snapToGrid = e;
|
|
});
|
|
try {
|
|
localStorage.setItem("canvas:snapToGrid", String(e));
|
|
} catch {}
|
|
},
|
|
setReadonly: (e) => {
|
|
s((t) => {
|
|
t.isReadonly = e;
|
|
});
|
|
},
|
|
setBoxSelecting: (e) => {
|
|
s((t) => {
|
|
t.isBoxSelecting = e;
|
|
});
|
|
},
|
|
setInteracting: (e) => {
|
|
s((t) => {
|
|
t.isInteracting = e;
|
|
});
|
|
},
|
|
}
|
|
),
|
|
),
|
|
{ name: "CanvasStore" },
|
|
),
|
|
);
|
|
return (o = s), s;
|
|
};
|
|
e.s(
|
|
[
|
|
"convertBackendNodeTypeToFrontend",
|
|
() => ef,
|
|
"convertEdgeToConnection",
|
|
() => ev,
|
|
"convertNodeToCanvasNode",
|
|
() => ey,
|
|
"createCanvasStore",
|
|
0,
|
|
eI,
|
|
"selectHasIncomingEdge",
|
|
() => ei,
|
|
"selectHasOutgoingEdge",
|
|
() => er,
|
|
"selectIsAnyConnected",
|
|
() => el,
|
|
"selectIsConnected",
|
|
() => es,
|
|
"selectNodeData",
|
|
() => ea,
|
|
"selectNodeResourceMeta",
|
|
() => ed,
|
|
"selectResourceMetaByTaskId",
|
|
() => ec,
|
|
"selectResourceMetaByUrl",
|
|
() => eu,
|
|
],
|
|
929286,
|
|
);
|
|
let e_ = { text: null, image: null, video: null, audio: null },
|
|
eE = {
|
|
enhanceVideo: "video",
|
|
enhanceImage: "image",
|
|
scriptImage: "image",
|
|
scriptText: "text",
|
|
storyboardVideo: "video",
|
|
},
|
|
eM = {
|
|
text: null,
|
|
image: null,
|
|
video: null,
|
|
audio: null,
|
|
enhanceVideo: null,
|
|
enhanceImage: null,
|
|
scriptImage: null,
|
|
scriptText: null,
|
|
storyboardVideo: null,
|
|
};
|
|
var eC = e.i(546372),
|
|
eN = e.i(505e3),
|
|
eP = e.i(677588),
|
|
ek = e.i(135623);
|
|
let eT = { page: 1, pageSize: 20 };
|
|
var eO = e.i(627164);
|
|
function eA(e) {
|
|
e.uuid &&
|
|
(0, ek.setCookieLongTerm)(eN.USER_UUID_COOKIE_KEY, e.uuid, {
|
|
secure: !0,
|
|
sameSite: "none",
|
|
}),
|
|
(0, eO.setUserinfoToLocalStorage)(e);
|
|
}
|
|
let eD = (0, o.createContext)(null);
|
|
function eL({
|
|
children: e,
|
|
initialUser: i,
|
|
initialLang: r,
|
|
initialAreaCode: l,
|
|
}) {
|
|
let p = (0, o.useRef)(null);
|
|
return (
|
|
p.current ||
|
|
(p.current = {
|
|
langStore: (0, c.createStore)()(
|
|
(0, d.devtools)(
|
|
(0, u.immer)((e) => ({
|
|
lang: r || "zh",
|
|
setLang: (t) => {
|
|
let n;
|
|
e((e) => {
|
|
e.lang = t;
|
|
}),
|
|
(0, eP.reportLog)({
|
|
e: "user_language",
|
|
var: { lang: t },
|
|
tp: "log_acceptor_front_aws_lovart",
|
|
}),
|
|
(0, ek.setCookieLongTerm)(eN.LOCALE_COOKIE_KEY, t);
|
|
let o = window.location.pathname,
|
|
i = o.split("/").filter(Boolean);
|
|
if (
|
|
i.length > 0 &&
|
|
((n = i[0]), eC.i18n.locales.includes(n))
|
|
) {
|
|
if (t === eC.i18n.defaultLocale) {
|
|
let e = "/" + i.slice(1).join("/");
|
|
window.location.href = e || "/";
|
|
return;
|
|
}
|
|
let e = "/" + t + "/" + i.slice(1).join("/");
|
|
window.location.href = e;
|
|
return;
|
|
}
|
|
if (t !== eC.i18n.defaultLocale) {
|
|
window.location.href = "/" + t + o;
|
|
return;
|
|
}
|
|
window.location.reload();
|
|
},
|
|
})),
|
|
{ name: "LangStore" },
|
|
),
|
|
),
|
|
areaStore: (0, s.createAreaStore)(),
|
|
globalStore: (0, c.createStore)()(
|
|
(0, d.devtools)(
|
|
(0, u.immer)((e, t) => ({
|
|
schema: e_,
|
|
support: eM,
|
|
defaultModel: { video: "", image: "", audio: "", text: "" },
|
|
cameraControl: null,
|
|
slashImage: null,
|
|
setSlashImage: (t) =>
|
|
e((e) => {
|
|
e.slashImage = t;
|
|
}),
|
|
getModelSchema: (e) => {
|
|
let n = t();
|
|
for (let t of ["text", "image", "video", "audio"]) {
|
|
let o = n.schema[t];
|
|
if (o && o[e]) return o[e];
|
|
}
|
|
return null;
|
|
},
|
|
getModel(e, n) {
|
|
let o = t(),
|
|
i = eE[e] ?? e,
|
|
r = o.schema[i];
|
|
if (null == r) return null;
|
|
let a = r[n];
|
|
return null != a ? a : null;
|
|
},
|
|
setInitData: (t) =>
|
|
e((e) => {
|
|
if (void 0 !== t.modelSchema) {
|
|
let n = t.modelSchema,
|
|
o = n?.default;
|
|
Object.assign(e, {
|
|
schema: {
|
|
text: n?.textModels ?? null,
|
|
image: n?.imageModels ?? null,
|
|
video: n?.videoModels ?? null,
|
|
audio: n?.audioModels ?? null,
|
|
},
|
|
defaultModel: o
|
|
? {
|
|
text: o.text ?? "",
|
|
image: o.image ?? "",
|
|
video: o.video ?? "",
|
|
audio: o.audio ?? "",
|
|
}
|
|
: { text: "", image: "", video: "", audio: "" },
|
|
});
|
|
}
|
|
if (void 0 !== t.supportModels) {
|
|
let n = t.supportModels;
|
|
e.support = {
|
|
text: n?.text ?? null,
|
|
image: n?.image ?? null,
|
|
video: n?.video ?? null,
|
|
audio: n?.audio ?? null,
|
|
enhanceVideo: n?.enhanceVideo ?? null,
|
|
enhanceImage: n?.enhanceImage ?? null,
|
|
scriptImage: n?.scriptImage ?? null,
|
|
scriptText: n?.scriptText ?? null,
|
|
storyboardVideo: n?.storyboardVideo ?? null,
|
|
};
|
|
}
|
|
void 0 !== t.cameraControl &&
|
|
(e.cameraControl = t.cameraControl ?? null);
|
|
}),
|
|
setVoiceList: (t) => {
|
|
e((e) => {
|
|
e.voiceList = t;
|
|
});
|
|
},
|
|
voiceList: null,
|
|
cascadeColumn: 0,
|
|
setCascadeColumn: (t) =>
|
|
e((e) => {
|
|
e.cascadeColumn = t;
|
|
}),
|
|
})),
|
|
{ name: "GlobalStore" },
|
|
),
|
|
),
|
|
canvasStore: eI(),
|
|
projectStore: (0, c.createStore)()(
|
|
(0, d.devtools)(
|
|
(0, u.immer)((e) => ({
|
|
projectList: [],
|
|
total: 0,
|
|
isLoadingList: !1,
|
|
setProjectList: (t, n) => {
|
|
e((e) => {
|
|
(e.projectList = t), (e.total = n);
|
|
});
|
|
},
|
|
setLoadingList: (t) => {
|
|
e((e) => {
|
|
e.isLoadingList = t;
|
|
});
|
|
},
|
|
clearProjectList: () => {
|
|
e((e) => {
|
|
(e.projectList = []), (e.total = 0);
|
|
});
|
|
},
|
|
})),
|
|
{ name: "ProjectStore" },
|
|
),
|
|
),
|
|
mediaAssetStore: (0, c.createStore)()(
|
|
(0, d.devtools)(
|
|
(0, u.immer)((e) => ({
|
|
assetList: [],
|
|
total: 0,
|
|
isLoadingList: !1,
|
|
currentAsset: null,
|
|
isLoadingDetail: !1,
|
|
tagTreeMap: {},
|
|
isLoadingTagTree: !1,
|
|
assetTypes: [],
|
|
assetTypesLoaded: !1,
|
|
listFilter: { ...eT },
|
|
setAssetList: (t, n) => {
|
|
e((e) => {
|
|
(e.assetList = t), (e.total = n);
|
|
});
|
|
},
|
|
appendAssetList: (t, n) => {
|
|
e((e) => {
|
|
e.assetList.push(...t), void 0 !== n && (e.total = n);
|
|
});
|
|
},
|
|
setLoadingList: (t) => {
|
|
e((e) => {
|
|
e.isLoadingList = t;
|
|
});
|
|
},
|
|
clearAssetList: () => {
|
|
e((e) => {
|
|
(e.assetList = []), (e.total = 0);
|
|
});
|
|
},
|
|
setCurrentAsset: (t) => {
|
|
e((e) => {
|
|
e.currentAsset = t;
|
|
});
|
|
},
|
|
setLoadingDetail: (t) => {
|
|
e((e) => {
|
|
e.isLoadingDetail = t;
|
|
});
|
|
},
|
|
setTagTree: (t, n) => {
|
|
e((e) => {
|
|
e.tagTreeMap[t] = n;
|
|
});
|
|
},
|
|
setLoadingTagTree: (t) => {
|
|
e((e) => {
|
|
e.isLoadingTagTree = t;
|
|
});
|
|
},
|
|
setAssetTypes: (t) => {
|
|
e((e) => {
|
|
(e.assetTypes = t), (e.assetTypesLoaded = !0);
|
|
});
|
|
},
|
|
setListFilter: (t) => {
|
|
e((e) => {
|
|
Object.assign(e.listFilter, t);
|
|
});
|
|
},
|
|
resetListFilter: () => {
|
|
e((e) => {
|
|
e.listFilter = { ...eT };
|
|
});
|
|
},
|
|
removeAssetFromList: (t) => {
|
|
e((e) => {
|
|
(e.assetList = e.assetList.filter((e) => e.uuid !== t)),
|
|
(e.total = Math.max(0, e.total - 1));
|
|
});
|
|
},
|
|
updateAssetInList: (t, n) => {
|
|
e((e) => {
|
|
let o = e.assetList.findIndex((e) => e.uuid === t);
|
|
if (-1 !== o) {
|
|
let t = Object.entries(n).filter(
|
|
([, e]) => void 0 !== e,
|
|
);
|
|
Object.assign(e.assetList[o], Object.fromEntries(t));
|
|
}
|
|
});
|
|
},
|
|
prependAssetToList: (t) => {
|
|
e((e) => {
|
|
e.assetList.unshift(t), (e.total += 1);
|
|
});
|
|
},
|
|
})),
|
|
{ name: "MediaAssetStore" },
|
|
),
|
|
),
|
|
userStore:
|
|
(i && eA(i),
|
|
(0, c.createStore)()(
|
|
(0, d.devtools)(
|
|
(0, u.immer)((e) => ({
|
|
isLogin: !!i,
|
|
userInfo: i || null,
|
|
setUserInfo: (t) => {
|
|
eA(t),
|
|
e((e) => {
|
|
(e.isLogin = !0), (e.userInfo = t);
|
|
});
|
|
},
|
|
logout: () => {
|
|
e((e) => {
|
|
(e.isLogin = !1), (e.userInfo = null);
|
|
});
|
|
},
|
|
})),
|
|
{ name: "UserStore" },
|
|
),
|
|
)),
|
|
communityStore: (0, c.createStore)()(
|
|
(0, d.devtools)(
|
|
(0, u.immer)((e) => ({
|
|
items: [],
|
|
total: 0,
|
|
cacheMeta: null,
|
|
cacheScrollY: 0,
|
|
cacheActiveTag: 0,
|
|
setItems: (t) =>
|
|
e((e) => {
|
|
e.items = t;
|
|
}),
|
|
setTotal: (t) =>
|
|
e((e) => {
|
|
e.total = t;
|
|
}),
|
|
appendItems: (t) =>
|
|
e((e) => {
|
|
e.items.push(...t);
|
|
}),
|
|
toggleLike: (t) =>
|
|
e((e) => {
|
|
let n = e.items.find((e) => e.id === t);
|
|
n &&
|
|
((n.isLiked = !n.isLiked),
|
|
(n.likeCount += n.isLiked ? 1 : -1));
|
|
}),
|
|
updateItem: (t, n) =>
|
|
e((e) => {
|
|
let o = e.items.find((e) => e.id === t);
|
|
o && Object.assign(o, n);
|
|
}),
|
|
setCacheMeta: (t) =>
|
|
e((e) => {
|
|
e.cacheMeta = t;
|
|
}),
|
|
setCacheScrollY: (t) =>
|
|
e((e) => {
|
|
e.cacheScrollY = t;
|
|
}),
|
|
setCacheActiveTag: (t) =>
|
|
e((e) => {
|
|
e.cacheActiveTag = t;
|
|
}),
|
|
reset: () =>
|
|
e((e) => {
|
|
(e.items = []),
|
|
(e.total = 0),
|
|
(e.cacheMeta = null),
|
|
(e.cacheScrollY = 0);
|
|
}),
|
|
})),
|
|
{ name: "CommunityStore" },
|
|
),
|
|
),
|
|
activityAwardedStore: (0, a.createActivityAwardedStore)(),
|
|
projectDetailStore: (0, c.createStore)()(
|
|
(0, d.devtools)(
|
|
(0, u.immer)((e) => ({
|
|
projectId: "",
|
|
items: [],
|
|
currentIndex: 0,
|
|
isPlaying: !1,
|
|
processModalOpen: !1,
|
|
init: (t, n, o) =>
|
|
e((e) => {
|
|
(e.projectId = t),
|
|
(e.items = n),
|
|
(e.currentIndex = o),
|
|
(e.isPlaying = !1);
|
|
}),
|
|
setItems: (t) =>
|
|
e((e) => {
|
|
e.items = t;
|
|
}),
|
|
setCurrentIndex: (t) =>
|
|
e((e) => {
|
|
e.currentIndex = t;
|
|
}),
|
|
setIsPlaying: (t) =>
|
|
e((e) => {
|
|
e.isPlaying = t;
|
|
}),
|
|
setProcessModalOpen: (t) =>
|
|
e((e) => {
|
|
e.processModalOpen = t;
|
|
}),
|
|
toggleLike: (t) =>
|
|
e((e) => {
|
|
let n = e.items.find((e) => e.id === t);
|
|
n &&
|
|
((n.isLiked = !n.isLiked),
|
|
(n.likeCount += n.isLiked ? 1 : -1));
|
|
}),
|
|
updateItem: (t, n) =>
|
|
e((e) => {
|
|
let o = e.items.find((e) => e.id === t);
|
|
o && Object.assign(o, n);
|
|
}),
|
|
reset: () =>
|
|
e((e) => {
|
|
(e.projectId = ""),
|
|
(e.items = []),
|
|
(e.currentIndex = 0),
|
|
(e.isPlaying = !1),
|
|
(e.processModalOpen = !1);
|
|
}),
|
|
})),
|
|
{ name: "ProjectDetailStore" },
|
|
),
|
|
),
|
|
uiStore: (0, c.createStore)()(
|
|
(0, d.devtools)(
|
|
(0, u.immer)((e) => ({
|
|
activeSidebarPanel: null,
|
|
activityBannerHeight: 0,
|
|
toggleSidebarPanel: (t) =>
|
|
e(
|
|
(e) => {
|
|
e.activeSidebarPanel =
|
|
e.activeSidebarPanel === t ? null : t;
|
|
},
|
|
!1,
|
|
"ui/toggleSidebarPanel",
|
|
),
|
|
closeSidebarPanel: () =>
|
|
e(
|
|
(e) => {
|
|
e.activeSidebarPanel = null;
|
|
},
|
|
!1,
|
|
"ui/closeSidebarPanel",
|
|
),
|
|
setActivityBannerHeight: (t) =>
|
|
e(
|
|
(e) => {
|
|
e.activityBannerHeight = t;
|
|
},
|
|
!1,
|
|
"ui/setActivityBannerHeight",
|
|
),
|
|
})),
|
|
{ name: "uiStore" },
|
|
),
|
|
),
|
|
}),
|
|
(t = p.current),
|
|
l && t.areaStore.getState().setAreaCode(l),
|
|
(0, n.jsx)(eD.Provider, { value: p.current, children: e })
|
|
);
|
|
}
|
|
function ej() {
|
|
let e = (0, o.useContext)(eD);
|
|
if (e) return e;
|
|
if (t) return t;
|
|
throw Error("Missing RootStoreProvider");
|
|
}
|
|
function eR(e) {
|
|
return function (t) {
|
|
let n = ej()[e];
|
|
return (0, r.useStoreWithEqualityFn)(n, t ?? ((e) => e), i.shallow);
|
|
};
|
|
}
|
|
eR("langStore"), eR("areaStore");
|
|
let ez = eR("globalStore"),
|
|
eF = eR("canvasStore"),
|
|
e$ = eR("projectStore"),
|
|
eB = eR("mediaAssetStore"),
|
|
eH = eR("userStore"),
|
|
eV = eR("communityStore"),
|
|
eU = eR("activityAwardedStore"),
|
|
eY = eR("projectDetailStore"),
|
|
eW = eR("uiStore");
|
|
e.s(
|
|
[
|
|
"RootStoreProvider",
|
|
() => eL,
|
|
"stores",
|
|
0,
|
|
{
|
|
get lang() {
|
|
return t ? t.langStore.getState() : null;
|
|
},
|
|
get area() {
|
|
return t ? t.areaStore.getState() : null;
|
|
},
|
|
get global() {
|
|
return t ? t.globalStore.getState() : null;
|
|
},
|
|
get canvas() {
|
|
return t ? t.canvasStore.getState() : null;
|
|
},
|
|
get project() {
|
|
return t ? t.projectStore.getState() : null;
|
|
},
|
|
get mediaAsset() {
|
|
return t ? t.mediaAssetStore.getState() : null;
|
|
},
|
|
get user() {
|
|
return t ? t.userStore.getState() : null;
|
|
},
|
|
get community() {
|
|
return t ? t.communityStore.getState() : null;
|
|
},
|
|
get activityAwarded() {
|
|
return t ? t.activityAwardedStore.getState() : null;
|
|
},
|
|
get projectDetail() {
|
|
return t ? t.projectDetailStore.getState() : null;
|
|
},
|
|
get ui() {
|
|
return t ? t.uiStore.getState() : null;
|
|
},
|
|
},
|
|
"useActivityAwardedStore",
|
|
0,
|
|
eU,
|
|
"useCanvasStore",
|
|
0,
|
|
eF,
|
|
"useCommunityStore",
|
|
0,
|
|
eV,
|
|
"useGlobalStore",
|
|
0,
|
|
ez,
|
|
"useMediaAssetStore",
|
|
0,
|
|
eB,
|
|
"useProjectDetailStore",
|
|
0,
|
|
eY,
|
|
"useProjectStore",
|
|
0,
|
|
e$,
|
|
"useRootStore",
|
|
() => ej,
|
|
"useUiStore",
|
|
0,
|
|
eW,
|
|
"useUserStore",
|
|
0,
|
|
eH,
|
|
],
|
|
216257,
|
|
);
|
|
};
|
|
|
|
export default moduleFactory;
|