pixi.js
Version:
<p align="center"> <a href="https://pixijs.com" target="_blank" rel="noopener noreferrer"> <img height="150" src="https://files.pixijs.download/branding/pixijs-logo-transparent-dark.svg?v=1" alt="PixiJS logo"> </a> </p> <br/> <p align="center">
266 lines (264 loc) • 8.88 kB
JavaScript
;
var ExtensionType = /* @__PURE__ */ ((ExtensionType2) => {
ExtensionType2["Application"] = "application";
ExtensionType2["WebGLPipes"] = "webgl-pipes";
ExtensionType2["WebGLPipesAdaptor"] = "webgl-pipes-adaptor";
ExtensionType2["WebGLSystem"] = "webgl-system";
ExtensionType2["WebGPUPipes"] = "webgpu-pipes";
ExtensionType2["WebGPUPipesAdaptor"] = "webgpu-pipes-adaptor";
ExtensionType2["WebGPUSystem"] = "webgpu-system";
ExtensionType2["CanvasSystem"] = "canvas-system";
ExtensionType2["CanvasPipesAdaptor"] = "canvas-pipes-adaptor";
ExtensionType2["CanvasPipes"] = "canvas-pipes";
ExtensionType2["Asset"] = "asset";
ExtensionType2["LoadParser"] = "load-parser";
ExtensionType2["ResolveParser"] = "resolve-parser";
ExtensionType2["CacheParser"] = "cache-parser";
ExtensionType2["DetectionParser"] = "detection-parser";
ExtensionType2["MaskEffect"] = "mask-effect";
ExtensionType2["BlendMode"] = "blend-mode";
ExtensionType2["TextureSource"] = "texture-source";
ExtensionType2["Environment"] = "environment";
ExtensionType2["ShapeBuilder"] = "shape-builder";
ExtensionType2["Batcher"] = "batcher";
return ExtensionType2;
})(ExtensionType || {});
const normalizeExtension = (ext) => {
if (typeof ext === "function" || typeof ext === "object" && ext.extension) {
if (!ext.extension) {
throw new Error("Extension class must have an extension object");
}
const metadata = typeof ext.extension !== "object" ? { type: ext.extension } : ext.extension;
ext = { ...metadata, ref: ext };
}
if (typeof ext === "object") {
ext = { ...ext };
} else {
throw new Error("Invalid extension type");
}
if (typeof ext.type === "string") {
ext.type = [ext.type];
}
return ext;
};
const normalizeExtensionPriority = (ext, defaultPriority) => normalizeExtension(ext).priority ?? defaultPriority;
const extensions = {
/** @ignore */
_addHandlers: {},
/** @ignore */
_removeHandlers: {},
/** @ignore */
_queue: {},
/**
* Remove extensions from PixiJS.
* @param extensions - Extensions to be removed. Can be:
* - Extension class with static `extension` property
* - Extension format object with `type` and `ref`
* - Multiple extensions as separate arguments
* @returns {extensions} this for chaining
* @example
* ```ts
* // Remove a single extension
* extensions.remove(MyRendererPlugin);
*
* // Remove multiple extensions
* extensions.remove(
* MyRendererPlugin,
* MySystemPlugin
* );
* ```
* @see {@link ExtensionType} For available extension types
* @see {@link ExtensionFormat} For extension format details
*/
remove(...extensions2) {
extensions2.map(normalizeExtension).forEach((ext) => {
ext.type.forEach((type) => this._removeHandlers[type]?.(ext));
});
return this;
},
/**
* Register new extensions with PixiJS. Extensions can be registered in multiple formats:
* - As a class with a static `extension` property
* - As an extension format object
* - As multiple extensions passed as separate arguments
* @param extensions - Extensions to add to PixiJS. Each can be:
* - A class with static `extension` property
* - An extension format object with `type` and `ref`
* - Multiple extensions as separate arguments
* @returns This extensions instance for chaining
* @example
* ```ts
* // Register a simple extension
* extensions.add(MyRendererPlugin);
*
* // Register multiple extensions
* extensions.add(
* MyRendererPlugin,
* MySystemPlugin,
* });
* ```
* @see {@link ExtensionType} For available extension types
* @see {@link ExtensionFormat} For extension format details
* @see {@link extensions.remove} For removing registered extensions
*/
add(...extensions2) {
extensions2.map(normalizeExtension).forEach((ext) => {
ext.type.forEach((type) => {
const handlers = this._addHandlers;
const queue = this._queue;
if (!handlers[type]) {
queue[type] = queue[type] || [];
queue[type]?.push(ext);
} else {
handlers[type]?.(ext);
}
});
});
return this;
},
/**
* Internal method to handle extensions by name.
* @param type - The extension type.
* @param onAdd - Function handler when extensions are added/registered {@link StrictExtensionFormat}.
* @param onRemove - Function handler when extensions are removed/unregistered {@link StrictExtensionFormat}.
* @returns this for chaining.
* @internal
* @ignore
*/
handle(type, onAdd, onRemove) {
const addHandlers = this._addHandlers;
const removeHandlers = this._removeHandlers;
if (addHandlers[type] || removeHandlers[type]) {
throw new Error(`Extension type ${type} already has a handler`);
}
addHandlers[type] = onAdd;
removeHandlers[type] = onRemove;
const queue = this._queue;
if (queue[type]) {
queue[type]?.forEach((ext) => onAdd(ext));
delete queue[type];
}
return this;
},
/**
* Handle a type, but using a map by `name` property.
* @param type - Type of extension to handle.
* @param map - The object map of named extensions.
* @returns this for chaining.
* @ignore
*/
handleByMap(type, map) {
return this.handle(
type,
(extension) => {
if (extension.name) {
map[extension.name] = extension.ref;
}
},
(extension) => {
if (extension.name) {
delete map[extension.name];
}
}
);
},
/**
* Handle a type, but using a list of extensions with a `name` property.
* @param type - Type of extension to handle.
* @param map - The array of named extensions.
* @param defaultPriority - Fallback priority if none is defined.
* @returns this for chaining.
* @ignore
*/
handleByNamedList(type, map, defaultPriority = -1) {
return this.handle(
type,
(extension) => {
const index = map.findIndex((item) => item.name === extension.name);
if (index >= 0)
return;
map.push({ name: extension.name, value: extension.ref });
map.sort((a, b) => normalizeExtensionPriority(b.value, defaultPriority) - normalizeExtensionPriority(a.value, defaultPriority));
},
(extension) => {
const index = map.findIndex((item) => item.name === extension.name);
if (index !== -1) {
map.splice(index, 1);
}
}
);
},
/**
* Handle a type, but using a list of extensions.
* @param type - Type of extension to handle.
* @param list - The list of extensions.
* @param defaultPriority - The default priority to use if none is specified.
* @returns this for chaining.
* @ignore
*/
handleByList(type, list, defaultPriority = -1) {
return this.handle(
type,
(extension) => {
if (list.includes(extension.ref)) {
return;
}
list.push(extension.ref);
list.sort((a, b) => normalizeExtensionPriority(b, defaultPriority) - normalizeExtensionPriority(a, defaultPriority));
},
(extension) => {
const index = list.indexOf(extension.ref);
if (index !== -1) {
list.splice(index, 1);
}
}
);
},
/**
* Mixin the source object(s) properties into the target class's prototype.
* Copies all property descriptors from source objects to the target's prototype.
* @param Target - The target class to mix properties into
* @param sources - One or more source objects containing properties to mix in
* @example
* ```ts
* // Create a mixin with shared properties
* const moveable = {
* x: 0,
* y: 0,
* move(x: number, y: number) {
* this.x += x;
* this.y += y;
* }
* };
*
* // Create a mixin with computed properties
* const scalable = {
* scale: 1,
* get scaled() {
* return this.scale > 1;
* }
* };
*
* // Apply mixins to a class
* extensions.mixin(Sprite, moveable, scalable);
*
* // Use mixed-in properties
* const sprite = new Sprite();
* sprite.move(10, 20);
* console.log(sprite.x, sprite.y); // 10, 20
* ```
* @remarks
* - Copies all properties including getters/setters
* - Does not modify source objects
* - Preserves property descriptors
* @see {@link Object.defineProperties} For details on property descriptors
* @see {@link Object.getOwnPropertyDescriptors} For details on property copying
*/
mixin(Target, ...sources) {
for (const source of sources) {
Object.defineProperties(Target.prototype, Object.getOwnPropertyDescriptors(source));
}
}
};
export { ExtensionType, extensions, normalizeExtensionPriority };
//# sourceMappingURL=Extensions.mjs.map