@laplace.live/pixijs-live2d 0.5.0 → 0.6.0

package/dist/index.d.ts

@@ -3337,6 +3337,11 @@ export declare abstract class MotionManager<Motion = unknown, MotionSpec = unkno
    * is dropped; a higher-priority motion in flight hands over to the new selection when it ends.
    */
   setIdleMotion(motion: IdleMotion): void;
+  /**
+   * List a motion file after load, under `group`, so a file written beside the model plays
+   * without a reload. A new group is created; an existing one grows by one index.
+   */
+  addMotion(group: string, definition: MotionSpec): void;
   /** Stop the idle so the next update starts the selection. Cubism eases its parameters home too. */
   protected releaseIdle(): void;
   /** Start the idle selection at IDLE priority; a chosen motion loops regardless of its own flag. */
@@ -3560,7 +3565,9 @@ export declare abstract class ExpressionManager<Expression = unknown, Expression
    */
   tag: string;
   /**
-   * Expression definitions copied from ModelSettings.
+   * Expression definitions copied from ModelSettings. An index is not stable across an `await`:
+   * {@link removeDefinition} shifts the ones above it, so a load or activation in flight
+   * re-resolves its definition afterwards rather than trusting the index it started with.
    */
   abstract readonly definitions: ExpressionSpec[];
   /**
@@ -3593,6 +3600,14 @@ export declare abstract class ExpressionManager<Expression = unknown, Expression
    * Active set remembered by {@link resetExpression} for {@link restoreExpression}.
    */
   protected suppressedIndices: number[] | null;
+  /**
+   * Indices whose parameters are skipped while they stay active — an editor previewing an
+   * expression's own edit needs the real one silent without touching the active set anyone
+   * persists or observes.
+   */
+  protected muted: Set<number>;
+  /** Every entry silenced at once (the editor's Solo), on top of {@link muted}. */
+  protected muteAll: boolean;
   /**
    * Flags the instance has been destroyed.
    */
@@ -3612,6 +3627,40 @@ export declare abstract class ExpressionManager<Expression = unknown, Expression
    * @ignore
    */
   private _loadExpression;
+  /**
+   * Lists a definition after load, so a file written beside the model activates without a reload.
+   * @return The new index.
+   */
+  addDefinition(definition: ExpressionSpec): number;
+  /**
+   * Replaces the loaded Expression at `index` — a file the editor just rewrote — keeping an active one
+   * active at its current weight.
+   */
+  replaceExpression(index: number, expression: Expression): void;
+  /**
+   * Forgets a definition (its file was deleted or renamed away): deactivates it, then shifts every
+   * index above it so the remaining expressions keep their state. An activation of it still loading
+   * settles as a no-op.
+   */
+  removeDefinition(index: number): void;
+  /**
+   * Mutes or unmutes an Expression: an active one keeps its state and fade but contributes nothing
+   * until unmuted. Unknown indices are ignored.
+   */
+  setExpressionMuted(index: number | string, muted: boolean): void;
+  /**
+   * Mutes or unmutes every Expression at once, active state untouched; the per-entry mutes stay
+   * as they are underneath.
+   */
+  setAllMuted(muted: boolean): void;
+  /**
+   * A loaded Expression was swapped for another at `index`; a subclass holding it live re-points.
+   */
+  protected onExpressionReplaced(_index: number, _expression: Expression): void;
+  /**
+   * The definition at `index` is gone and every index above it moved down by one.
+   */
+  protected onDefinitionRemoved(_index: number): void;
   /**
    * Activates a random inactive Expression.
    * @return Promise that resolves with true if succeeded, with false otherwise.
@@ -4675,7 +4724,8 @@ export declare class Live2DFactory {
   /**
    * Load tasks of each expression.
    */
-  static expressionTasksMap: WeakMap<ExpressionManager<unknown, unknown>, (Promise<any> | undefined)[]>;
+  /** Keyed by the definition object: a removal shifts indices, never the object. */
+  static expressionTasksMap: WeakMap<ExpressionManager<unknown, unknown>, Map<unknown, Promise<any>>>;
   /**
    * Registers a Live2DRuntime.
    */
@@ -5761,9 +5811,15 @@ export declare class CubismModelSettings extends ModelSettings {
 export declare class CubismExpressionManager extends ExpressionManager<CubismExpressionMotion, Expression> {
   readonly expressionDataType: "arraybuffer";
   readonly definitions: Expression[];
+  /** The settings the listings read; `definitions` was filtered out of them, so both are kept in step. */
+  private readonly cubismSettings;
   /** Active fade entries in activation order; deactivated ones stay until fully faded out. */
   private entries;
   constructor(settings: CubismModelSettings, options?: MotionManagerOptions);
+  addDefinition(definition: Expression): number;
+  removeDefinition(index: number): void;
+  protected onExpressionReplaced(index: number, expression: CubismExpressionMotion): void;
+  protected onDefinitionRemoved(index: number): void;
   isFinished(): boolean;
   getExpressionIndex(name: string): number;
   getExpressionFile(definition: Expression): string;
@@ -6945,6 +7001,12 @@ export declare class CubismMotionManager extends MotionManager<CubismMotion, Mot
   isFinished(): boolean;
   protected _startMotion(motion: CubismMotion, onFinish?: (motion: CubismMotion) => void, ignoreParamIds?: string[], loop?: boolean): number;
   protected _stopAllMotions(): void;
+  /**
+   * Fade the queue's motions out over their own fade-out time instead of cutting them; each
+   * ends like a natural finish (idle restart, `motionFinish`), which is how a looping one stops.
+   * The motion's sound stops at once, as it does on {@link stopAllMotions}.
+   */
+  fadeOutMotions(): void;
   createMotion(data: ArrayBuffer, group: string, definition: Motion): CubismMotion;
   getMotionFile(definition: Motion): string;
   protected getMotionName(definition: Motion): string;
@@ -6953,6 +7015,13 @@ export declare class CubismMotionManager extends MotionManager<CubismMotion, Mot
   currentMotionBlinks(): boolean;
   /** The parameters the playing motion writes, for a host driver handing them over to it; null when none plays. */
   currentMotionParameters(): ReadonlySet<string> | null;
+  /**
+   * The parameters a playing one-shot (anything above IDLE) writes — what a host's tracking
+   * yields to while it plays, as VTS ranks an animation above tracking. Null under the idle.
+   */
+  oneShotParameters(): ReadonlySet<string> | null;
+  /** A motion above idle priority is current — one the player started, never the idle. */
+  oneShotPlaying(): boolean;
   private currentMotion;
   private currentMeta;
   protected releaseIdle(): void;

package/dist/index.js

@@ -2734,6 +2734,14 @@ var ExpressionManager = class extends EventEmitter {
 	*/
 	suppressedIndices = null;
 	/**
+	* Indices whose parameters are skipped while they stay active — an editor previewing an
+	* expression's own edit needs the real one silent without touching the active set anyone
+	* persists or observes.
+	*/
+	muted = /* @__PURE__ */ new Set();
+	/** Every entry silenced at once (the editor's Solo), on top of {@link muted}. */
+	muteAll = false;
+	/**
 	* Flags the instance has been destroyed.
 	*/
 	destroyed = false;
@@ -2751,7 +2759,8 @@ var ExpressionManager = class extends EventEmitter {
 	* @emits {@link ExpressionManagerEvents.expressionLoadError}
 	*/
 	async loadExpression(index) {
-		if (!this.definitions[index]) {
+		const definition = this.definitions[index];
+		if (!definition) {
 			logger.warn(this.tag, `Undefined expression at [${index}]`);
 			return;
 		}
@@ -2762,7 +2771,11 @@ var ExpressionManager = class extends EventEmitter {
 		if (this.expressions[index]) return this.expressions[index];
 		const expression = await this._loadExpression(index);
 		if (this.destroyed) return;
-		this.expressions[index] = expression;
+		const slot = this.definitions.indexOf(definition);
+		if (slot < 0) return;
+		const replaced = this.expressions[slot];
+		if (replaced) return replaced;
+		this.expressions[slot] = expression;
 		return expression;
 	}
 	/**
@@ -2773,6 +2786,66 @@ var ExpressionManager = class extends EventEmitter {
 		throw new Error("Not implemented.");
 	}
 	/**
+	* Lists a definition after load, so a file written beside the model activates without a reload.
+	* @return The new index.
+	*/
+	addDefinition(definition) {
+		this.definitions.push(definition);
+		return this.definitions.length - 1;
+	}
+	/**
+	* Replaces the loaded Expression at `index` — a file the editor just rewrote — keeping an active one
+	* active at its current weight.
+	*/
+	replaceExpression(index, expression) {
+		if (!this.definitions[index]) return;
+		this.expressions[index] = expression;
+		this.onExpressionReplaced(index, expression);
+	}
+	/**
+	* Forgets a definition (its file was deleted or renamed away): deactivates it, then shifts every
+	* index above it so the remaining expressions keep their state. An activation of it still loading
+	* settles as a no-op.
+	*/
+	removeDefinition(index) {
+		if (!(index >= 0 && index < this.definitions.length)) return;
+		this.unsetExpression(index);
+		this.definitions.splice(index, 1);
+		this.expressions.splice(index, 1);
+		const shift = (i) => i > index ? i - 1 : i;
+		this.activeIndices = this.activeIndices.map(shift);
+		this.pendingIndices = new Set([...this.pendingIndices].map(shift));
+		this.requestSeqs = new Map([...this.requestSeqs].map(([i, seq]) => [shift(i), seq]));
+		if (this.suppressedIndices) this.suppressedIndices = this.suppressedIndices.filter((i) => i !== index).map(shift);
+		this.muted = new Set([...this.muted].filter((i) => i !== index).map(shift));
+		this.onDefinitionRemoved(index);
+	}
+	/**
+	* Mutes or unmutes an Expression: an active one keeps its state and fade but contributes nothing
+	* until unmuted. Unknown indices are ignored.
+	*/
+	setExpressionMuted(index, muted) {
+		if (typeof index !== "number") index = this.getExpressionIndex(index);
+		if (!this.definitions[index]) return;
+		if (muted) this.muted.add(index);
+		else this.muted.delete(index);
+	}
+	/**
+	* Mutes or unmutes every Expression at once, active state untouched; the per-entry mutes stay
+	* as they are underneath.
+	*/
+	setAllMuted(muted) {
+		this.muteAll = muted;
+	}
+	/**
+	* A loaded Expression was swapped for another at `index`; a subclass holding it live re-points.
+	*/
+	onExpressionReplaced(_index, _expression) {}
+	/**
+	* The definition at `index` is gone and every index above it moved down by one.
+	*/
+	onDefinitionRemoved(_index) {}
+	/**
 	* Activates a random inactive Expression.
 	* @return Promise that resolves with true if succeeded, with false otherwise.
 	*/
@@ -2837,14 +2910,17 @@ var ExpressionManager = class extends EventEmitter {
 	*/
 	async setExpression(index, options) {
 		if (typeof index !== "number") index = this.getExpressionIndex(index);
-		if (!(index > -1 && index < this.definitions.length)) return false;
+		const definition = this.definitions[index];
+		if (!definition) return false;
 		if (this.activeIndices.includes(index) || this.pendingIndices.has(index)) return false;
 		this.pendingIndices.add(index);
 		const seq = this.nextRequestSeq++;
 		this.requestSeqs.set(index, seq);
 		this.emit("expressionsChanged");
 		const expression = await this.loadExpression(index);
-		if (this.destroyed || this.requestSeqs.get(index) !== seq || !this.pendingIndices.has(index)) return false;
+		if (this.destroyed) return false;
+		index = this.definitions.indexOf(definition);
+		if (index < 0 || this.requestSeqs.get(index) !== seq || !this.pendingIndices.has(index)) return false;
 		if (!expression) {
 			this.pendingIndices.delete(index);
 			this.requestSeqs.delete(index);
@@ -2911,6 +2987,8 @@ var ExpressionManager = class extends EventEmitter {
 		this.requestSeqs.clear();
 		this.activeIndices = [];
 		this.suppressedIndices = null;
+		this.muted.clear();
+		this.muteAll = false;
 		this.stopAllExpressions();
 		const self = this;
 		self.definitions = void 0;
@@ -3986,6 +4064,16 @@ var MotionManager = class extends EventEmitter {
 		this.state.setReservedIdle(void 0, void 0);
 		if (this.state.currentPriority === 1) this.releaseIdle();
 	}
+	/**
+	* List a motion file after load, under `group`, so a file written beside the model plays
+	* without a reload. A new group is created; an existing one grows by one index.
+	*/
+	addMotion(group, definition) {
+		const definitions = this.definitions[group] ?? [];
+		definitions.push(definition);
+		this.definitions[group] = definitions;
+		this.motionGroups[group] ??= [];
+	}
 	/** Stop the idle so the next update starts the selection. Cubism eases its parameters home too. */
 	releaseIdle() {
 		this.stopAllMotions();
@@ -4871,6 +4959,7 @@ var Live2DFactory = class Live2DFactory {
 	/**
 	* Load tasks of each expression.
 	*/
+	/** Keyed by the definition object: a removal shifts indices, never the object. */
 	static expressionTasksMap = /* @__PURE__ */ new WeakMap();
 	/**
 	* Registers a Live2DRuntime.
@@ -4969,28 +5058,33 @@ var Live2DFactory = class Live2DFactory {
 			expressionManager.once("destroy", () => Live2DFactory.releaseExpressionTasks(expressionManager));
 			let tasks = Live2DFactory.expressionTasksMap.get(expressionManager);
 			if (!tasks) {
-				tasks = [];
+				tasks = /* @__PURE__ */ new Map();
 				Live2DFactory.expressionTasksMap.set(expressionManager, tasks);
 			}
 			const path = expressionManager.getExpressionFile(definition);
 			const responseType = expressionManager.expressionDataType ?? "json";
-			tasks[index] ??= Live2DLoader.load({
-				url: path,
-				settings: expressionManager.settings,
-				type: responseType,
-				target: expressionManager
-			}).then((data) => {
-				const tasks = Live2DFactory.expressionTasksMap.get(expressionManager);
-				if (tasks) tasks[index] = void 0;
-				const expressionData = data;
-				const expression = expressionManager.createExpression(expressionData, definition);
-				expressionManager.emit("expressionLoaded", index, expression);
-				return expression;
-			}).catch((e) => {
-				logger.warn(expressionManager.tag, `Failed to load expression: ${path}\n`, e);
-				handleError(e);
-			});
-			return tasks[index];
+			let task = tasks.get(definition);
+			if (!task) {
+				task = Live2DLoader.load({
+					url: path,
+					settings: expressionManager.settings,
+					type: responseType,
+					target: expressionManager
+				}).then((data) => {
+					const expressionData = data;
+					const expression = expressionManager.createExpression(expressionData, definition);
+					const current = expressionManager.definitions.indexOf(definition);
+					if (current >= 0) expressionManager.emit("expressionLoaded", current, expression);
+					return expression;
+				}).catch((e) => {
+					logger.warn(expressionManager.tag, `Failed to load expression: ${path}\n`, e);
+					handleError(e);
+				}).finally(() => {
+					Live2DFactory.expressionTasksMap.get(expressionManager)?.delete(definition);
+				});
+				tasks.set(definition, task);
+			}
+			return task;
 		} catch (e) {
 			logger.warn(expressionManager.tag, `Failed to load expression at [${index}]\n`, e);
 			handleError(e);
@@ -14600,12 +14694,39 @@ let Live2DCubismFramework$2;
 var CubismExpressionManager = class extends ExpressionManager {
 	expressionDataType = "arraybuffer";
 	definitions;
+	/** The settings the listings read; `definitions` was filtered out of them, so both are kept in step. */
+	cubismSettings;
 	/** Active fade entries in activation order; deactivated ones stay until fully faded out. */
 	entries = [];
 	constructor(settings, options) {
 		super(settings, options);
+		this.cubismSettings = settings;
 		this.definitions = settings.expressions?.filter((expression) => !!expression && typeof expression.File === "string" && typeof expression.Name === "string") ?? [];
 	}
+	addDefinition(definition) {
+		const index = super.addDefinition(definition);
+		this.cubismSettings.expressions ??= [];
+		this.cubismSettings.expressions.push(definition);
+		return index;
+	}
+	removeDefinition(index) {
+		const definition = this.definitions[index];
+		super.removeDefinition(index);
+		const listed = this.cubismSettings.expressions;
+		const at = definition && listed ? listed.indexOf(definition) : -1;
+		if (listed && at >= 0) listed.splice(at, 1);
+	}
+	onExpressionReplaced(index, expression) {
+		for (const entry of this.entries) if (entry.index === index) {
+			entry.motion = expression;
+			entry.fadeStartWeight = entry.weight;
+			entry.fadeStartTime = -1;
+		}
+	}
+	onDefinitionRemoved(index) {
+		this.entries = this.entries.filter((entry) => entry.index !== index);
+		for (const entry of this.entries) if (entry.index > index) entry.index -= 1;
+	}
 	isFinished() {
 		return this.entries.length === 0;
 	}
@@ -14662,6 +14783,7 @@ var CubismExpressionManager = class extends ExpressionManager {
 		if (!this.entries.length) return false;
 		const states = /* @__PURE__ */ new Map();
 		for (const entry of this.entries) {
+			if (this.muteAll || this.muted.has(entry.index)) continue;
 			const weight = entry.weight;
 			for (const parameter of entry.motion.getExpressionParameters()) {
 				if (parameter.parameterId == null) continue;
@@ -14730,7 +14852,8 @@ var CubismMotionManager = class extends MotionManager {
 	release = null;
 	constructor(parent) {
 		super(parent);
-		this.definitions = parent.settings.motions ?? {};
+		parent.settings.motions ??= {};
+		this.definitions = parent.settings.motions;
 		this.eyeBlinkIds = parent.settings.getEyeBlinkParameters() || [];
 		const lipSyncIds = parent.settings.getLipSyncParameters();
 		if (lipSyncIds?.length) this.lipSyncIds = lipSyncIds;
@@ -14738,7 +14861,7 @@ var CubismMotionManager = class extends MotionManager {
 	}
 	init(options) {
 		super.init(options);
-		if (this.settings.expressions) this.expressionManager = new CubismExpressionManager(this.settings, options);
+		this.expressionManager = new CubismExpressionManager(this.settings, options);
 		this.queueManager.setEventCallback((_caller, eventValue) => {
 			const value = eventValue == null ? "undefined" : String(eventValue);
 			this.emit(`motion:${value}`);
@@ -14765,6 +14888,15 @@ var CubismMotionManager = class extends MotionManager {
 	_stopAllMotions() {
 		this.queueManager.stopAllMotions();
 	}
+	/**
+	* Fade the queue's motions out over their own fade-out time instead of cutting them; each
+	* ends like a natural finish (idle restart, `motionFinish`), which is how a looping one stops.
+	* The motion's sound stops at once, as it does on {@link stopAllMotions}.
+	*/
+	fadeOutMotions() {
+		for (const entry of this.queueManager.getCubismMotionQueueEntries()) entry.setFadeOut(entry._motion.getFadeOutTime());
+		this.stopSpeaking();
+	}
 	createMotion(data, group, definition) {
 		const shouldCheckMotionConsistency = !!this.parent.options.checkMotionConsistency;
 		const motion = CubismMotion.create(data, data.byteLength, void 0, void 0, shouldCheckMotionConsistency);
@@ -14772,8 +14904,8 @@ var CubismMotionManager = class extends MotionManager {
 		motion.setLoop(json.isMotionLoop());
 		this.meta.set(motion, motionMeta(motion, this.eyeBlinkIds));
 		const defaultFadingDuration = (group === this.groups.idle ? config.idleMotionFadingDuration : config.motionFadingDuration) / 1e3;
-		if (json.getMotionFadeInTime() === void 0) motion.setFadeInTime(definition.FadeInTime > 0 ? definition.FadeInTime : defaultFadingDuration);
-		if (json.getMotionFadeOutTime() === void 0) motion.setFadeOutTime(definition.FadeOutTime > 0 ? definition.FadeOutTime : defaultFadingDuration);
+		if (!json.isExistMotionFadeInTime()) motion.setFadeInTime(definition.FadeInTime > 0 ? definition.FadeInTime : defaultFadingDuration);
+		if (!json.isExistMotionFadeOutTime()) motion.setFadeOutTime(definition.FadeOutTime > 0 ? definition.FadeOutTime : defaultFadingDuration);
 		motion.setEffectIds(this.createIdList(this.eyeBlinkIds), this.createIdList(this.lipSyncIds));
 		return motion;
 	}
@@ -14794,6 +14926,17 @@ var CubismMotionManager = class extends MotionManager {
 	currentMotionParameters() {
 		return this.currentMeta()?.animated ?? null;
 	}
+	/**
+	* The parameters a playing one-shot (anything above IDLE) writes — what a host's tracking
+	* yields to while it plays, as VTS ranks an animation above tracking. Null under the idle.
+	*/
+	oneShotParameters() {
+		return this.oneShotPlaying() ? this.currentMotionParameters() : null;
+	}
+	/** A motion above idle priority is current — one the player started, never the idle. */
+	oneShotPlaying() {
+		return this.state.currentPriority > 1;
+	}
 	currentMotion() {
 		const { currentGroup, currentIndex } = this.state;
 		if (currentGroup === void 0 || currentIndex === void 0) return null;