@tawaship/pixim-animate-runtime 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tawaship
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,281 @@
-# Temporary Holding Version
+# @tawaship/pixim-animate-runtime
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Plays content made in Adobe Animate (published for HTML5 Canvas) in [Pixim.js](https://github.com/tawaship/Pixim.js)
+applications, without CreateJS.
+
+- **Convert once, at development time**: the command of
+  [@tawaship/pixi-animate-runtime](https://github.com/tawaship/pixi-animate-runtime) turns the files Animate
+  publishes into an optimized *runtime content* file
+- **Load it as an asset of a Pixim content and play it in a Pixim container**: the runtime content loads with
+  the content's other assets, and plays as CreateJS would, without CreateJS and without the published files
+- **What it brings**: the player of pixi-animate-runtime (light instance creation, even playback, checked frame
+  by frame against CreateJS), included in this package
+
+Coming from [@tawaship/pixim-animate-container](https://github.com/tawaship/Pixim-animate-container)? It plays the
+same content and is used the same way; see [Coming from pixim-animate-container](#coming-from-pixim-animate-container).
+
+**Status: under development.**
+
+API reference: https://tawaship.github.io/Pixim-animate-runtime/docs/
+
+Samples (content published from Animate, played by this package or by CreateJS): https://tawaship.github.io/Pixim-animate-runtime/samples/
+
+**Convert only content you trust.** Converting (with pixi-animate-runtime's command) runs the published
+JavaScript, frame scripts included. It runs in a sandbox that is given nothing of your machine, but running code
+is never without risk: convert content published by you or by people you trust, and treat content you receive as
+code you would run (see [the note in its README](https://github.com/tawaship/pixi-animate-runtime#readme)).
+
+## Quick start
+
+The published files are needed only to convert. Your application ships the runtime content (and the images it
+uses), not the published files. This example keeps them apart:
+
+```
+my-project/
+├─ animate/          what Animate publishes (read when converting; not shipped)
+└─ public/           what the application ships
+   ├─ animates/      the runtime content, written by the command
+   ├─ lib/           PixiJS, Pixim.js and this package
+   └─ index.html
+```
+
+1. **Publish from Animate.** In Adobe Animate, publish the document for HTML5 Canvas into `animate/` (you get
+   `title.js`, `title.html` and an `images/` directory).
+
+2. **Install.** In the project (Node.js 18 or later):
+
+   ```
+   npm install pixi.js@5 @tawaship/pixim.js @tawaship/pixim-animate-runtime
+   npm install --save-dev @tawaship/pixi-animate-runtime
+   ```
+
+   pixi-animate-runtime brings the command that converts (the player itself is in this package). Copy
+   `node_modules/pixi.js/dist/pixi.min.js`, `node_modules/@tawaship/pixim.js/dist/Pixim.min.js` and
+   `node_modules/@tawaship/pixim-animate-runtime/dist/pixim-animate-runtime.js` into `public/lib/` (or import them
+   with a bundler).
+
+3. **Convert.** From the project's root:
+
+   ```
+   npx --no-install @tawaship/pixi-animate-runtime animate --out-dir public/animates
+   ```
+
+   It lists what it will write and asks; answer `y`. This writes `public/animates/title.js` (the runtime
+   content) and copies the images it uses into `public/animates/images/`. The list shows the content's
+   **composition id**, which the next step needs.
+
+4. **Play.** In `public/index.html`, load PixiJS, Pixim.js and this package, define the content as an asset of
+   a Pixim content, and put the symbol the published HTML showed (named after the published file, here `title`)
+   on an `AnimateContainer`:
+
+   ```html
+   <script src="lib/pixi.min.js"></script>
+   <script src="lib/Pixim.min.js"></script>
+   <script src="lib/pixim-animate-runtime.js"></script>
+   <script>
+   const { defineAnimateContentsTo, AnimateContainer } = Pixim.animateRuntime;
+
+   const Game = Pixim.Content.create();
+   defineAnimateContentsTo(Game, {
+   	title: { id: '<composition id>', basepath: 'animates/', filepath: 'title.js' }
+   });
+   Game.defineLibraries({
+   	root: class Root extends Pixim.Container {
+   		constructor($) {
+   			super();
+   			const container = new AnimateContainer();
+   			this.addChild(container);
+   			container.addCreatejs($.resources.animateContents.title.create('title'));
+   		}
+   	}
+   });
+
+   const app = new Pixim.Application({ width: 550, height: 400 });
+   app.attachAsync(new Game()).then(() => app.play());
+   </script>
+   ```
+
+   The runtime content and its images load with the Pixim content's other assets, and the content plays at the
+   frame rate it was published with.
+
+5. **After publishing again from Animate, run step 3 again.** The player plays the runtime content, never the
+   published files: a change made in Animate shows only once the runtime content is made again.
+
+The sections below explain [defining contents](#playing-content), the [options](#options-of-the-pixim-content)
+of the Pixim content and the [container](#playing). Converting is explained in
+[pixi-animate-runtime's README](https://github.com/tawaship/pixi-animate-runtime#converting-published-content).
+
+## What you need
+
+- PixiJS 5.3 (`pixi.js` ^5.3.2) and Pixim.js 1.15 (`@tawaship/pixim.js` ^1.15.2) in your application
+- Runtime content files, made from the published content with the command line tool of pixi-animate-runtime
+  (`npx --no-install @tawaship/pixi-animate-runtime <published directory>`)
+
+## Supported versions
+
+- Content published by **Adobe Animate 24.0.15** for HTML5 Canvas. What this package reads is the form of the published
+  JavaScript, which depends on the version of Animate; content published by other versions has not been checked
+- PixiJS 5.3 (`pixi.js` ^5.3.2). Checked with 5.3.9
+- Pixim.js 1.15 (`@tawaship/pixim.js` ^1.15.2). Checked with 1.15.2
+
+## Playing content
+
+Load this package after Pixi.js and Pixim.js. It includes the player: do not load pixi-animate-runtime as well.
+What the player does (the objects and their PixiJS nodes, what is supported, the current limits) is as described in
+[pixi-animate-runtime's README](https://github.com/tawaship/pixi-animate-runtime#readme).
+
+```html
+<script src="pixi.js"></script>
+<script src="Pixim.js"></script>
+<script src="pixim-animate-runtime.js"></script>
+```
+
+Define the contents a Pixim content uses, by name, and take them from `$.resources.animateContents` in its
+classes:
+
+```js
+const { defineAnimateContentsTo, AnimateContainer } = Pixim.animateRuntime;
+
+const Game = Pixim.Content.create();
+
+defineAnimateContentsTo(Game, {
+	title: { id: '2FA8E0C7230941478CE2CA3DB82DBEDF', basepath: 'assets/animates/', filepath: 'title.js' }
+});
+
+class Root extends Pixim.Container {
+	constructor($) {
+		super();
+		const content = $.resources.animateContents.title;
+		const container = new AnimateContainer();
+		this.addChild(container);
+		container.addCreatejs(content.create('title'));   // the symbol the published HTML used as its root
+	}
+}
+
+Game.defineLibraries({ root: Root });
+```
+
+When the application attaches the content, the runtime content file and the content's images are loaded with
+the content's other assets, and the `title` symbol plays at the frame rate it was published with while the
+container is on the display tree.
+
+- `id` is the composition id (the command line tool prints it, and it is written at the top of the runtime
+  content file)
+- `basepath` is the directory the runtime content file and the content's images are in, relative to the base
+  path of the Pixim content (its `basepath` option)
+- `filepath` is the runtime content file, relative to `basepath`. Without it, the file has to be loaded
+  already (by a script tag, for example)
+- `options` takes what pixi-animate-runtime's `loadContentAsync` takes: `crossOrigin: false` loads the images
+  without CORS, and `handleManifest(manifest)` is called with the content's images (`{ id, src }`) before they are
+  loaded, so that their `src` can be changed for this load (to a `data:` URL, for example)
+- `defineAnimateContentsTo(Game, targets, { unrequired: true })` gives `null` for a content that could not be
+  loaded instead of failing the whole Pixim content. `addAnimateContentsTo(game, targets)` adds contents to
+  one instance of a Pixim content
+
+What `$.resources.animateContents.title` holds is the content as pixi-animate-runtime's `loadContentAsync`
+gives it: `id`, `lib`, `properties` and `create(id)`.
+
+### Options of the Pixim content
+
+The options a Pixim content is created with apply as they do to its other assets:
+
+```js
+new Game({
+	basepath: 'https://example.com/',
+	version: 12,
+	xhr: { requestOptions: { credentials: 'include' } },
+	typeOptions: { animateContents: { fileVersion: 3, assetVersion: 5 } }
+});
+```
+
+- `version` adds `_fv=<version>` to the URLs of the runtime content files and the images (the query Animate
+  adds to each image path on every publish stays). `fileVersion` and `assetVersion` under
+  `typeOptions.animateContents` set it for the files and for the images separately
+- With `xhr`, the runtime content files and the images are fetched with its request options. The images are
+  fetched after the target's `handleManifest` is called, so an image it gives a `data:` URL is not fetched
+
+### Playing
+
+`AnimateContainer` is a Pixim container. While it is on the display tree of a running application, every
+frame of the application plays the roots put on it with `addCreatejs`, at their content's frame rate.
+
+- `taskEnabled = false` stops playing; the container's `task` is free for your own use (clearing it does not
+  stop playing)
+- `speed` changes the playback speed (`1` is the published frame rate, `0` stops; a value below `0` stops it as `0`
+  does). `overSpeed = false` plays at
+  most one frame per frame of the application
+- `smooth` (`true` by default) keeps the playing even when the time between frames of the application varies a
+  little, while keeping to the real time, as described for pixi-animate-runtime. `false` plays by the time of
+  each frame as it is
+- `removeCreatejs(instance)` takes an instance off; a movie clip put on again starts from its first frame
+
+Everything pixi-animate-runtime exports is in `Pixim.animateRuntime` too (`loadContentAsync`, `tick`, the
+CreateJS-compatible classes, `VERSION` and so on), except that `AnimateContainer` is the Pixim container.
+With a bundler, import from `@tawaship/pixim-animate-runtime`.
+
+## Coming from pixim-animate-container
+
+pixim-animate-container loads CreateJS and the published JavaScript as assets of a Pixim content and runs them
+in the browser. This package loads runtime content files instead, generated from the published JavaScript at
+development time: CreateJS is not loaded, and after publishing again from Animate the runtime content has to
+be generated again. How the content is played otherwise changes as described for pixi-animate-runtime
+(see its README).
+
+Contents are defined and used the same way, under new names:
+
+| pixim-animate-container | pixim-animate-runtime |
+|---|---|
+| A `<script>` tag for CreateJS | None |
+| `Pixim.animate` | `Pixim.animateRuntime` |
+| `defineAnimatesTo(Game, { name: { id, basepath, filepath } })`, `filepath` being the published `.js` | `defineAnimateContentsTo(Game, { name: { id, basepath, filepath } })`, `filepath` being the runtime content file |
+| `addAnimatesTo` | `addAnimateContentsTo` |
+| `$.resources.animates.name`, the `lib` of the content | `$.resources.animateContents.name`, the content (its classes are in `content.lib`) |
+| `new $.resources.animates.name.game()` | `$.resources.animateContents.name.create('game')` |
+| `Pixim.animate.Container` | `AnimateContainer` |
+| `createjsSpeed` | `speed` |
+| `createjsOverSpeed` | `overSpeed` |
+| (none) | `smooth` (on by default; `false` plays as pixim-animate-container does) |
+
+Not available: `replaceInstance()` on movie clips and `replaceTexture()` on sprites and bitmaps, besides what
+pixi-animate-runtime does not have.
+
+## Claude Code skills
+
+The package comes with skills for Claude Code (Anthropic's AI coding tool) in `dist-skills/`: `pixim-animate-runtime-guide`, which tells it how to load and play runtime content in Pixim.js, and the skills of the packages it builds on (`pixi-animate-runtime-guide`, `animate-data-converter-guide`). To
+let Claude Code use them in your project, copy them into the project's `.claude/skills/`:
+
+```
+mkdir -p .claude/skills
+cp -r node_modules/@tawaship/pixim-animate-runtime/dist-skills/* .claude/skills/
+```
+
+Copy them again after updating the package. Each skill names the versions it was written for; with another
+version, it tells Claude Code to follow the type definitions in `node_modules` where they disagree.
+
+## How correctness is checked
+
+This package was developed with Claude (Anthropic's AI assistant). Its correctness rests on testing rather
+than on trust in the author: it is run with Pixim.js, and what it loads (URLs, versions, request options,
+images fetched into blob: URLs and released) and how its container plays (frame by frame, against the player
+of pixi-animate-runtime given the same frame times) are compared with what is expected. Known faults are put
+into the package on purpose to confirm that the comparison notices them.
+
+## Change log
+
+### 0.1.1
+
+- A `speed` below `0` stops the playing as `0` does, and it goes on at once when the speed is above `0` again
+- Built with pixi-animate-runtime 0.1.1: right after a goto made outside the playing (from a pointer event, for
+  example), synched and single frame clips, and clips coming back on the display list, are drawn as CreateJS shows
+  them from the first draw after the goto, not at their old frame until the content plays its next frame
+
+### 0.1.0
+
+- First release: loads runtime content as an asset of a Pixim content (`defineAnimateContentsTo`, `addAnimateContentsTo`,
+  with the Pixim content's `version` and `xhr`) and plays it in a Pixim container (`AnimateContainer`, with `speed`,
+  `overSpeed` and `smooth`)
+- Claude Code skills in `dist-skills/`, published with the package
+
+## License
+
+MIT

package/dist/pixim-animate-runtime.cjs.js

@@ -0,0 +1,236 @@
+/*!
+ * @tawaship/pixim-animate-runtime - v0.1.1
+ * 
+ * @require pixi.js ^5.3.2
+ * @require @tawaship/pixim.js ^1.15.2
+ * @author tawaship (makazu.mori@gmail.com)
+ * @license MIT
+ */
+
+'use strict';
+
+var pixiAnimateRuntime = require('@tawaship/pixi-animate-runtime');
+var pixim_js = require('@tawaship/pixim.js');
+
+/**
+ * A Pixim container that plays the content roots put on it at their
+ * content's frame rate (the rate the content was published with), while it is
+ * on the display tree of a running Pixim application.
+ *
+ * Each frame of the application plays `delta x speed x fps / 60` frames of every
+ * root (delta being the application ticker's), one frame being createjs's tick
+ * phase followed by its resolve phase; the first frame after a root is put on
+ * only settles it on its first frame. Playing stops while `taskEnabled` is
+ * false. The container's own `task` is free for the application: what it holds
+ * does not change the playing.
+ */
+var AnimateContainer = /*@__PURE__*/(function (Container) {
+    function AnimateContainer() {
+        Container.call(this);
+        this._controller = new pixiAnimateRuntime.AnimateController(this);
+    }
+
+    if ( Container ) AnimateContainer.__proto__ = Container;
+    AnimateContainer.prototype = Object.create( Container && Container.prototype );
+    AnimateContainer.prototype.constructor = AnimateContainer;
+
+    var prototypeAccessors = { speed: { configurable: true },overSpeed: { configurable: true },smooth: { configurable: true } };
+    /** Playback speed (1 is the content's own frame rate, 0 stops; a value below 0 is taken as 0) */
+    prototypeAccessors.speed.get = function () { return this._controller.speed; };
+    prototypeAccessors.speed.set = function (value) { this._controller.speed = value; };
+    /** Whether one frame of the application may play more than one frame of a root (when the display runs slower than the content) */
+    prototypeAccessors.overSpeed.get = function () { return this._controller.overSpeed; };
+    prototypeAccessors.overSpeed.set = function (value) { this._controller.overSpeed = value; };
+    /** Whether frames are played by a steady clock, so that small changes of the delta do not make the playing uneven */
+    prototypeAccessors.smooth.get = function () { return this._controller.smooth; };
+    prototypeAccessors.smooth.set = function (value) { this._controller.smooth = value; };
+    AnimateContainer.prototype.updateTask = function updateTask (e) {
+        Container.prototype.updateTask.call(this, e);
+        if (!this.taskEnabled) {
+            return;
+        }
+        this._controller.handleTick(e.delta);
+    };
+    /** Plays the roots by hand, as one frame of the application with this delta does */
+    AnimateContainer.prototype.handleTick = function handleTick (delta) {
+        this._controller.handleTick(delta);
+    };
+    /** Puts a content object on this container; a MovieClip plays from then on */
+    AnimateContainer.prototype.addCreatejs = function addCreatejs (obj) {
+        return this._controller.addCreatejs(obj);
+    };
+    AnimateContainer.prototype.addCreatejsAt = function addCreatejsAt (obj, index) {
+        return this._controller.addCreatejsAt(obj, index);
+    };
+    AnimateContainer.prototype.removeCreatejs = function removeCreatejs (obj) {
+        return this._controller.removeCreatejs(obj);
+    };
+
+    Object.defineProperties( AnimateContainer.prototype, prototypeAccessors );
+
+    return AnimateContainer;
+}(pixim_js.Container));
+
+var AnimateContentLoaderResource = /*@__PURE__*/(function (LoaderResource) {
+    function AnimateContentLoaderResource () {
+        LoaderResource.apply(this, arguments);
+    }
+
+    if ( LoaderResource ) AnimateContentLoaderResource.__proto__ = LoaderResource;
+    AnimateContentLoaderResource.prototype = Object.create( LoaderResource && LoaderResource.prototype );
+    AnimateContentLoaderResource.prototype.constructor = AnimateContentLoaderResource;
+
+    AnimateContentLoaderResource.prototype.destroy = function destroy () {
+        this._data = null;
+    };
+
+    return AnimateContentLoaderResource;
+}(pixim_js.LoaderResource));
+function isUrl(src) {
+    return src.indexOf('data:') !== 0 && src.indexOf('blob:') !== 0;
+}
+/**
+ * Loads a content as a Pixim asset: its runtime content file (when a filepath
+ * is given), then the content with loadContentAsync, the base path being the
+ * Pixim content's and the target's together.
+ *
+ * With the Pixim content's `xhr` option, the images are fetched (with its
+ * request options) into blob: URLs first, after the target's own
+ * handleManifest; the blob: URLs are released once the content is loaded.
+ */
+var AnimateContentLoader = /*@__PURE__*/(function (LoaderBase) {
+    function AnimateContentLoader () {
+        LoaderBase.apply(this, arguments);
+    }
+
+    if ( LoaderBase ) AnimateContentLoader.__proto__ = LoaderBase;
+    AnimateContentLoader.prototype = Object.create( LoaderBase && LoaderBase.prototype );
+    AnimateContentLoader.prototype.constructor = AnimateContentLoader;
+
+    AnimateContentLoader.prototype._loadAsync = function _loadAsync (target, options) {
+        var this$1$1 = this;
+        if ( options === void 0 ) options = {};
+
+        var basepath = pixiAnimateRuntime.resolveContentUrl(options.basepath || '', target.basepath || '');
+        return this._loadFileAsync(target, basepath, options)
+            .then(function () { return this$1$1._loadContentAsync(target, basepath, options); })
+            .then(function (content) { return new AnimateContentLoaderResource(content, null); })
+            .catch(function (e) { return new AnimateContentLoaderResource(null, e); });
+    };
+    AnimateContentLoader.prototype._loadFileAsync = function _loadFileAsync (target, basepath, options) {
+        if (!target.filepath) {
+            return Promise.resolve();
+        }
+        return new pixim_js.JsLoader().loadAsync(pixiAnimateRuntime.resolveContentUrl(basepath, target.filepath), { version: options.fileVersion || options.version, xhr: options.xhr })
+            .then(function (resource) {
+            if (resource.error) {
+                throw resource.error;
+            }
+            resource.ref();
+        });
+    };
+    AnimateContentLoader.prototype._loadContentAsync = function _loadContentAsync (target, basepath, options) {
+        var this$1$1 = this;
+
+        var version = options.assetVersion || options.version;
+        var blobs = [];
+        var release = function () {
+            blobs.forEach(function (blob) { return blob.destroy(); });
+        };
+        var own = target.options && target.options.handleManifest;
+        var contentTarget = {
+            id: target.id,
+            basepath: basepath,
+            options: {
+                crossOrigin: target.options ? target.options.crossOrigin : undefined,
+                handleManifest: function (manifest) {
+                    return Promise.resolve(own ? own(manifest) : undefined)
+                        .then(function () { return options.xhr ? this$1$1._fetchImagesAsync(manifest, basepath, version, options, blobs) : undefined; });
+                }
+            }
+        };
+        return pixiAnimateRuntime.loadContentAsync(contentTarget, { version: version })
+            .then(function (content) {
+            release();
+            return content;
+        }, function (e) {
+            release();
+            throw e;
+        });
+    };
+    /** The images fetched into blob: URLs, which then stand for their files */
+    AnimateContentLoader.prototype._fetchImagesAsync = function _fetchImagesAsync (manifest, basepath, version, options, blobs) {
+        var targets = {};
+        manifest.forEach(function (entry, i) {
+            if (isUrl(entry.src)) {
+                targets[i] = pixiAnimateRuntime.resolveContentUrl(basepath, entry.src);
+            }
+        });
+        return new pixim_js.BlobLoader().loadAllAsync(targets, { version: version, xhr: options.xhr })
+            .then(function (resources) {
+            Object.keys(resources).forEach(function (i) {
+                blobs.push(resources[i]);
+            });
+            Object.keys(resources).forEach(function (i) {
+                var resource = resources[i];
+                if (resource.error) {
+                    throw resource.error;
+                }
+                manifest[Number(i)].src = resource.data;
+            });
+        });
+    };
+
+    return AnimateContentLoader;
+}(pixim_js.LoaderBase));
+
+/** The key of the contents in a Pixim content's resources: `$.resources.animateContents` */
+var ANIMATE_CONTENTS = 'animateContents';
+var AnimateContentManifest = /*@__PURE__*/(function (ManifestBase) {
+    function AnimateContentManifest () {
+        ManifestBase.apply(this, arguments);
+    }
+
+    if ( ManifestBase ) AnimateContentManifest.__proto__ = ManifestBase;
+    AnimateContentManifest.prototype = Object.create( ManifestBase && ManifestBase.prototype );
+    AnimateContentManifest.prototype.constructor = AnimateContentManifest;
+
+    AnimateContentManifest.prototype._createLoader = function _createLoader () {
+        return new AnimateContentLoader();
+    };
+
+    return AnimateContentManifest;
+}(pixim_js.ManifestBase));
+pixim_js.Content.registerManifest(ANIMATE_CONTENTS, AnimateContentManifest);
+/**
+ * Defines contents for a Pixim content class: each is loaded with the class's
+ * other assets and given as `$.resources.animateContents[name]`.
+ */
+function defineAnimateContentsTo(PiximContent, targets, options) {
+    if ( options === void 0 ) options = {};
+
+    return PiximContent.defineTargets(ANIMATE_CONTENTS, targets, options);
+}
+/**
+ * Adds contents to a Pixim content instance (loaded with its other assets).
+ */
+function addAnimateContentsTo(content, targets, options) {
+    if ( options === void 0 ) options = {};
+
+    return content.addTargets(ANIMATE_CONTENTS, targets, options);
+}
+
+exports.ANIMATE_CONTENTS = ANIMATE_CONTENTS;
+exports.AnimateContainer = AnimateContainer;
+exports.AnimateContentLoader = AnimateContentLoader;
+exports.AnimateContentLoaderResource = AnimateContentLoaderResource;
+exports.AnimateContentManifest = AnimateContentManifest;
+exports.addAnimateContentsTo = addAnimateContentsTo;
+exports.defineAnimateContentsTo = defineAnimateContentsTo;
+Object.keys(pixiAnimateRuntime).forEach(function (k) {
+    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+        enumerable: true,
+        get: function () { return pixiAnimateRuntime[k]; }
+    });
+});
+//# sourceMappingURL=pixim-animate-runtime.cjs.js.map

package/dist/pixim-animate-runtime.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pixim-animate-runtime.cjs.js","sources":["../src/AnimateContainer.ts","../src/AnimateContentLoader.ts","../src/AnimateContentManifest.ts"],"sourcesContent":["import { Container, ITickerData } from '@tawaship/pixim.js';\nimport { AnimateController, DisplayObject } from '@tawaship/pixi-animate-runtime';\n\n/**\n * A Pixim container that plays the content roots put on it at their\n * content's frame rate (the rate the content was published with), while it is\n * on the display tree of a running Pixim application.\n *\n * Each frame of the application plays `delta x speed x fps / 60` frames of every\n * root (delta being the application ticker's), one frame being createjs's tick\n * phase followed by its resolve phase; the first frame after a root is put on\n * only settles it on its first frame. Playing stops while `taskEnabled` is\n * false. The container's own `task` is free for the application: what it holds\n * does not change the playing.\n */\nexport class AnimateContainer extends Container {\n\tprivate readonly _controller: AnimateController;\n\n\tconstructor() {\n\t\tsuper();\n\t\tthis._controller = new AnimateController(this);\n\t}\n\n\t/** Playback speed (1 is the content's own frame rate, 0 stops; a value below 0 is taken as 0) */\n\tget speed(): number { return this._controller.speed; }\n\tset speed(value: number) { this._controller.speed = value; }\n\n\t/** Whether one frame of the application may play more than one frame of a root (when the display runs slower than the content) */\n\tget overSpeed(): boolean { return this._controller.overSpeed; }\n\tset overSpeed(value: boolean) { this._controller.overSpeed = value; }\n\n\t/** Whether frames are played by a steady clock, so that small changes of the delta do not make the playing uneven */\n\tget smooth(): boolean { return this._controller.smooth; }\n\tset smooth(value: boolean) { this._controller.smooth = value; }\n\n\tupdateTask(e: ITickerData): void {\n\t\tsuper.updateTask(e);\n\t\tif (!this.taskEnabled) {\n\t\t\treturn;\n\t\t}\n\t\tthis._controller.handleTick(e.delta);\n\t}\n\n\t/** Plays the roots by hand, as one frame of the application with this delta does */\n\thandleTick(delta: number): void {\n\t\tthis._controller.handleTick(delta);\n\t}\n\n\t/** Puts a content object on this container; a MovieClip plays from then on */\n\taddCreatejs<T extends DisplayObject>(obj: T): T {\n\t\treturn this._controller.addCreatejs(obj);\n\t}\n\n\taddCreatejsAt<T extends DisplayObject>(obj: T, index: number): T {\n\t\treturn this._controller.addCreatejsAt(obj, index);\n\t}\n\n\tremoveCreatejs<T extends DisplayObject>(obj: T): T {\n\t\treturn this._controller.removeCreatejs(obj);\n\t}\n}\n","import { BlobLoader, BlobLoaderResource, ILoaderOption, JsLoader, LoaderBase, LoaderResource, TLoaderResourceVersion } from '@tawaship/pixim.js';\nimport { IContent, IContentManifestEntry, IContentTarget, loadContentAsync, resolveContentUrl } from '@tawaship/pixi-animate-runtime';\n\n/** A content to load: what loadContentAsync takes, and the runtime content file to load first */\nexport interface IAnimateContentLoaderTarget extends IContentTarget {\n\t/**\n\t * The runtime content file, relative to `basepath`. Loaded (as a script) before\n\t * the content when given; otherwise it has to be loaded already.\n\t */\n\tfilepath?: string;\n}\n\nexport interface IAnimateContentLoaderOption extends ILoaderOption {\n\t/** The version added to the runtime content file's URL (`version` when omitted) */\n\tfileVersion?: TLoaderResourceVersion;\n\t/** The version added to the image URLs (`version` when omitted) */\n\tassetVersion?: TLoaderResourceVersion;\n}\n\nexport class AnimateContentLoaderResource extends LoaderResource<IContent | null> {\n\tdestroy(): void {\n\t\tthis._data = null;\n\t}\n}\n\nfunction isUrl(src: string): boolean {\n\treturn src.indexOf('data:') !== 0 && src.indexOf('blob:') !== 0;\n}\n\n/**\n * Loads a content as a Pixim asset: its runtime content file (when a filepath\n * is given), then the content with loadContentAsync, the base path being the\n * Pixim content's and the target's together.\n *\n * With the Pixim content's `xhr` option, the images are fetched (with its\n * request options) into blob: URLs first, after the target's own\n * handleManifest; the blob: URLs are released once the content is loaded.\n */\nexport class AnimateContentLoader extends LoaderBase<IAnimateContentLoaderTarget, IContent | null, AnimateContentLoaderResource> {\n\tprotected _loadAsync(target: IAnimateContentLoaderTarget, options: IAnimateContentLoaderOption = {}): Promise<AnimateContentLoaderResource> {\n\t\tconst basepath = resolveContentUrl(options.basepath || '', target.basepath || '');\n\t\treturn this._loadFileAsync(target, basepath, options)\n\t\t\t.then(() => this._loadContentAsync(target, basepath, options))\n\t\t\t.then(content => new AnimateContentLoaderResource(content, null))\n\t\t\t.catch((e: Error) => new AnimateContentLoaderResource(null, e));\n\t}\n\n\tprivate _loadFileAsync(target: IAnimateContentLoaderTarget, basepath: string, options: IAnimateContentLoaderOption): Promise<void> {\n\t\tif (!target.filepath) {\n\t\t\treturn Promise.resolve();\n\t\t}\n\t\treturn new JsLoader().loadAsync(resolveContentUrl(basepath, target.filepath), { version: options.fileVersion || options.version, xhr: options.xhr })\n\t\t\t.then(resource => {\n\t\t\t\tif (resource.error) {\n\t\t\t\t\tthrow resource.error;\n\t\t\t\t}\n\t\t\t\tresource.ref();\n\t\t\t});\n\t}\n\n\tprivate _loadContentAsync(target: IAnimateContentLoaderTarget, basepath: string, options: IAnimateContentLoaderOption): Promise<IContent> {\n\t\tconst version = options.assetVersion || options.version;\n\t\tconst blobs: BlobLoaderResource[] = [];\n\t\tconst release = (): void => {\n\t\t\tblobs.forEach(blob => blob.destroy());\n\t\t};\n\t\tconst own = target.options && target.options.handleManifest;\n\t\tconst contentTarget: IContentTarget = {\n\t\t\tid: target.id,\n\t\t\tbasepath,\n\t\t\toptions: {\n\t\t\t\tcrossOrigin: target.options ? target.options.crossOrigin : undefined,\n\t\t\t\thandleManifest: (manifest: IContentManifestEntry[]) => {\n\t\t\t\t\treturn Promise.resolve(own ? own(manifest) : undefined)\n\t\t\t\t\t\t.then(() => options.xhr ? this._fetchImagesAsync(manifest, basepath, version, options, blobs) : undefined);\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t\treturn loadContentAsync(contentTarget, { version })\n\t\t\t.then(content => {\n\t\t\t\trelease();\n\t\t\t\treturn content;\n\t\t\t}, (e: Error) => {\n\t\t\t\trelease();\n\t\t\t\tthrow e;\n\t\t\t});\n\t}\n\n\t/** The images fetched into blob: URLs, which then stand for their files */\n\tprivate _fetchImagesAsync(manifest: IContentManifestEntry[], basepath: string, version: TLoaderResourceVersion | undefined, options: IAnimateContentLoaderOption, blobs: BlobLoaderResource[]): Promise<void> {\n\t\tconst targets: Record<string, string> = {};\n\t\tmanifest.forEach((entry, i) => {\n\t\t\tif (isUrl(entry.src)) {\n\t\t\t\ttargets[i] = resolveContentUrl(basepath, entry.src);\n\t\t\t}\n\t\t});\n\t\treturn new BlobLoader().loadAllAsync(targets, { version, xhr: options.xhr })\n\t\t\t.then(resources => {\n\t\t\t\tObject.keys(resources).forEach(i => {\n\t\t\t\t\tblobs.push(resources[i]);\n\t\t\t\t});\n\t\t\t\tObject.keys(resources).forEach(i => {\n\t\t\t\t\tconst resource = resources[i];\n\t\t\t\t\tif (resource.error) {\n\t\t\t\t\t\tthrow resource.error;\n\t\t\t\t\t}\n\t\t\t\t\tmanifest[Number(i)].src = resource.data;\n\t\t\t\t});\n\t\t\t});\n\t}\n}\n","import { Content, IManifestOption, ManifestBase } from '@tawaship/pixim.js';\nimport { IContent } from '@tawaship/pixi-animate-runtime';\nimport { AnimateContentLoader, AnimateContentLoaderResource, IAnimateContentLoaderTarget } from './AnimateContentLoader';\n\n/** The key of the contents in a Pixim content's resources: `$.resources.animateContents` */\nexport const ANIMATE_CONTENTS = 'animateContents';\n\nexport class AnimateContentManifest extends ManifestBase<IAnimateContentLoaderTarget, IContent | null, AnimateContentLoaderResource> {\n\tprotected _createLoader(): AnimateContentLoader {\n\t\treturn new AnimateContentLoader();\n\t}\n}\n\nContent.registerManifest(ANIMATE_CONTENTS, AnimateContentManifest);\n\n/**\n * Defines contents for a Pixim content class: each is loaded with the class's\n * other assets and given as `$.resources.animateContents[name]`.\n */\nexport function defineAnimateContentsTo(PiximContent: typeof Content, targets: Record<string, IAnimateContentLoaderTarget>, options: IManifestOption = {}): typeof Content {\n\treturn PiximContent.defineTargets(ANIMATE_CONTENTS, targets, options);\n}\n\n/**\n * Adds contents to a Pixim content instance (loaded with its other assets).\n */\nexport function addAnimateContentsTo(content: Content, targets: Record<string, IAnimateContentLoaderTarget>, options: IManifestOption = {}): Content {\n\treturn content.addTargets(ANIMATE_CONTENTS, targets, options);\n}\n"],"names":["super","AnimateController","Container","LoaderResource","const","resolveContentUrl","this","JsLoader","loadContentAsync","BlobLoader","LoaderBase","ManifestBase","Content"],"mappings":"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"}