@flighthq/particles-formats 0.1.0

package/dist/detect.d.ts

@@ -0,0 +1,18 @@
+import type { ParticleFormatKind } from '@flighthq/types';
+/** Sniff the text content of a particle file and return the format kind, or `null`
+ *  when no supported format is recognisable.
+ *
+ *  Detection is structural, not extension-based:
+ *  - libGDX `.p`: first non-empty line is `Particle Effect` (exact text).
+ *  - Starling PEX: XML containing `<particleEmitterConfig`.
+ *  - Particle Designer plist: XML containing `<plist`.
+ *  - Unity Shuriken JSON: root object contains `looping` or `startLifetime` with a
+ *    `mode` field (Unity's MinMaxCurve convention), or a `gravityModifier` key.
+ *  - Pixi particle JSON: root object contains `alpha` with a `start`/`end` sub-object
+ *    (pixi-particle-emitter shape) and a `pos` field.
+ *  - Spine JSON: root object contains `continuous` or `emission` with `{low,high}` range shape
+ *    (Spine's range-object convention) without Unity-specific keys.
+ *
+ *  Returns `null` for unknown or corrupt input — never throws. */
+export declare function detectParticleFormat(text: string): ParticleFormatKind | null;
+//# sourceMappingURL=detect.d.ts.map

package/dist/detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../src/detect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAU1D;;;;;;;;;;;;;;kEAckE;AAClE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CA8C5E"}

package/dist/detect.js

@@ -0,0 +1,75 @@
+import { LibgdxParticleFormatKind, ParticleDesignerFormatKind, PixiParticleFormatKind, SpineParticleFormatKind, StarlingPexFormatKind, UnityParticleFormatKind, } from '@flighthq/types';
+/** Sniff the text content of a particle file and return the format kind, or `null`
+ *  when no supported format is recognisable.
+ *
+ *  Detection is structural, not extension-based:
+ *  - libGDX `.p`: first non-empty line is `Particle Effect` (exact text).
+ *  - Starling PEX: XML containing `<particleEmitterConfig`.
+ *  - Particle Designer plist: XML containing `<plist`.
+ *  - Unity Shuriken JSON: root object contains `looping` or `startLifetime` with a
+ *    `mode` field (Unity's MinMaxCurve convention), or a `gravityModifier` key.
+ *  - Pixi particle JSON: root object contains `alpha` with a `start`/`end` sub-object
+ *    (pixi-particle-emitter shape) and a `pos` field.
+ *  - Spine JSON: root object contains `continuous` or `emission` with `{low,high}` range shape
+ *    (Spine's range-object convention) without Unity-specific keys.
+ *
+ *  Returns `null` for unknown or corrupt input — never throws. */
+export function detectParticleFormat(text) {
+    if (typeof text !== 'string')
+        return null;
+    const trimmed = text.trimStart();
+    // libGDX `.p` — first non-empty line is exactly "Particle Effect"
+    const firstLine = trimmed.split('\n')[0]?.trim();
+    if (firstLine === 'Particle Effect')
+        return LibgdxParticleFormatKind;
+    // XML path — Starling PEX or Particle Designer plist
+    if (trimmed.startsWith('<') || trimmed.startsWith('<?xml')) {
+        if (trimmed.includes('<particleEmitterConfig'))
+            return StarlingPexFormatKind;
+        if (trimmed.includes('<plist'))
+            return ParticleDesignerFormatKind;
+        return null;
+    }
+    // JSON path — disambiguate Spine vs Unity vs Pixi
+    let raw;
+    try {
+        raw = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const obj = raw;
+    // Unity: MinMaxCurve mode field, or gravityModifier, or looping + startLifetime
+    if (hasMinMaxCurveMode(obj.startLifetime) ||
+        hasMinMaxCurveMode(obj.startSpeed) ||
+        hasMinMaxCurveMode(obj.startSize) ||
+        typeof obj.gravityModifier === 'number' ||
+        (typeof obj.looping === 'boolean' && obj.startLifetime !== undefined)) {
+        return UnityParticleFormatKind;
+    }
+    // Pixi: has 'pos' + alpha.start/end or frequency field
+    if (obj.pos !== undefined &&
+        obj.alpha !== undefined &&
+        typeof obj.alpha === 'object' &&
+        obj.alpha !== null &&
+        ('start' in obj.alpha || 'end' in obj.alpha)) {
+        return PixiParticleFormatKind;
+    }
+    // Spine: has 'continuous' boolean or emission as {low, high} range object
+    if (typeof obj.continuous === 'boolean' || isRangeObject(obj.emission) || isRangeObject(obj.life)) {
+        return SpineParticleFormatKind;
+    }
+    return null;
+}
+function hasMinMaxCurveMode(val) {
+    return val !== null && typeof val === 'object' && typeof val.mode === 'string';
+}
+function isRangeObject(val) {
+    if (val === null || typeof val !== 'object')
+        return false;
+    const o = val;
+    return typeof o.low === 'number' && typeof o.high === 'number';
+}
+//# sourceMappingURL=detect.js.map

package/dist/detect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.js","sourceRoot":"","sources":["../src/detect.ts"],"names":[],"mappings":"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"}

package/dist/formatRegistry.d.ts

@@ -0,0 +1,60 @@
+import type { ParticleEmitterConfig } from '@flighthq/types';
+import type { ParticleFormatKind } from '@flighthq/types';
+import type { ParticleConfigParseResult } from './parseParticleConfig';
+import type { ParticleSerializeResult } from './serializeResult';
+/** Contract for a particle format codec registered via `registerParticleFormat`.
+ *
+ *  A codec provides the three operations needed to integrate a format into the
+ *  unified dispatcher: format detection, config parse, and serialize.
+ *
+ *  `detect` should return `true` when the text is confidently recognized as this format —
+ *  it must not throw. `parseToConfig` and `parseToDocument` may throw on genuinely
+ *  malformed input; the dispatcher catches and wraps errors as warnings. */
+export interface ParticleFormatCodec {
+    /** Return `true` when `text` is recognisable as this format. Must not throw. */
+    detect(text: string): boolean;
+    /** Parse `text` and return a `ParticleEmitterConfig`. May throw on malformed input. */
+    parseToConfig(text: string): ParticleEmitterConfig;
+    /** Parse `text` and return `{ config, warnings }`. May throw on malformed input.
+     *  Return an empty `warnings` array when nothing is lossy. */
+    parseToDocument(text: string): {
+        config: ParticleEmitterConfig;
+        warnings: string[];
+    };
+    /** Serialize `config` to the format string.
+     *  May accept optional options via closure capture in the codec implementation. */
+    serialize(config: Readonly<ParticleEmitterConfig>): ParticleSerializeResult;
+}
+/** Detect the format of `text` by consulting all registered codecs in registration order.
+ *
+ *  Returns the first `kind` whose codec's `detect` returns `true`, or `null` when no
+ *  registered codec recognises the input. Codecs are consulted in the order they were
+ *  registered; last-write-wins replacement does not change detection order (the replaced
+ *  kind retains its original position).
+ *
+ *  This is the registry-backed counterpart of `detectParticleFormat`. */
+export declare function detectRegisteredParticleFormat(text: string): string | null;
+/** Return the registered codec for `kind`, or `null` when no codec is registered. */
+export declare function getParticleFormatCodec(kind: ParticleFormatKind): ParticleFormatCodec | null;
+/** Return all currently registered format kinds. */
+export declare function getRegisteredParticleFormats(): ReadonlyArray<string>;
+/** Parse `text` using the registered codec for `kind`.
+ *
+ *  Returns a `ParticleConfigParseResult` with the config, format, and any import warnings.
+ *  When no codec is registered for `kind`, returns a default config with an
+ *  `'unknown-format'` warning. Codec errors are caught and returned as `'parse-error'` warnings. */
+export declare function parseRegisteredParticleFormat(text: string, kind: string): ParticleConfigParseResult;
+/** Register a particle format codec for the given `kind`.
+ *
+ *  Last-write-wins: registering the same kind again replaces the previous codec.
+ *  Built-in kinds (bare names, no dot) are registered at module load time by the
+ *  format packages themselves; custom/vendor kinds use a dotted namespace prefix
+ *  (e.g. `'acme.Custom'`).
+ *
+ *  This function must be called explicitly — there is no implicit registration at
+ *  module load time. */
+export declare function registerParticleFormat(kind: ParticleFormatKind, codec: ParticleFormatCodec): void;
+/** Remove a previously registered format codec. Returns `true` if the kind was found
+ *  and removed, `false` if it was not registered. */
+export declare function unregisterParticleFormat(kind: ParticleFormatKind): boolean;
+//# sourceMappingURL=formatRegistry.d.ts.map

package/dist/formatRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatRegistry.d.ts","sourceRoot":"","sources":["../src/formatRegistry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAEjE;;;;;;;4EAO4E;AAC5E,MAAM,WAAW,mBAAmB;IAClC,gFAAgF;IAChF,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC9B,uFAAuF;IACvF,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,CAAC;IACnD;kEAC8D;IAC9D,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG;QAC7B,MAAM,EAAE,qBAAqB,CAAC;QAC9B,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;IACF;uFACmF;IACnF,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,qBAAqB,CAAC,GAAG,uBAAuB,CAAC;CAC7E;AAED;;;;;;;yEAOyE;AACzE,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAS1E;AAED,qFAAqF;AACrF,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,kBAAkB,GAAG,mBAAmB,GAAG,IAAI,CAE3F;AAED,oDAAoD;AACpD,wBAAgB,4BAA4B,IAAI,aAAa,CAAC,MAAM,CAAC,CAEpE;AAED;;;;oGAIoG;AACpG,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,yBAAyB,CAmBnG;AAED;;;;;;;;wBAQwB;AACxB,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,mBAAmB,GAAG,IAAI,CAEjG;AAED;qDACqD;AACrD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAE1E"}

package/dist/formatRegistry.js

@@ -0,0 +1,75 @@
+import { createParticleEmitterConfig } from '@flighthq/particles';
+/** Detect the format of `text` by consulting all registered codecs in registration order.
+ *
+ *  Returns the first `kind` whose codec's `detect` returns `true`, or `null` when no
+ *  registered codec recognises the input. Codecs are consulted in the order they were
+ *  registered; last-write-wins replacement does not change detection order (the replaced
+ *  kind retains its original position).
+ *
+ *  This is the registry-backed counterpart of `detectParticleFormat`. */
+export function detectRegisteredParticleFormat(text) {
+    for (const [kind, codec] of _registry) {
+        try {
+            if (codec.detect(text))
+                return kind;
+        }
+        catch {
+            // A codec detect() must not throw; ignore any that do.
+        }
+    }
+    return null;
+}
+/** Return the registered codec for `kind`, or `null` when no codec is registered. */
+export function getParticleFormatCodec(kind) {
+    return _registry.get(kind) ?? null;
+}
+/** Return all currently registered format kinds. */
+export function getRegisteredParticleFormats() {
+    return [..._registry.keys()];
+}
+/** Parse `text` using the registered codec for `kind`.
+ *
+ *  Returns a `ParticleConfigParseResult` with the config, format, and any import warnings.
+ *  When no codec is registered for `kind`, returns a default config with an
+ *  `'unknown-format'` warning. Codec errors are caught and returned as `'parse-error'` warnings. */
+export function parseRegisteredParticleFormat(text, kind) {
+    const codec = _registry.get(kind);
+    if (!codec) {
+        return {
+            config: createParticleEmitterConfig(),
+            format: kind,
+            warnings: [`unknown-format: format '${kind}' has no registered codec`],
+        };
+    }
+    try {
+        const result = codec.parseToDocument(text);
+        return { config: result.config, format: kind, warnings: result.warnings };
+    }
+    catch (err) {
+        return {
+            config: createParticleEmitterConfig(),
+            format: kind,
+            warnings: [`parse-error: ${err.message}`],
+        };
+    }
+}
+/** Register a particle format codec for the given `kind`.
+ *
+ *  Last-write-wins: registering the same kind again replaces the previous codec.
+ *  Built-in kinds (bare names, no dot) are registered at module load time by the
+ *  format packages themselves; custom/vendor kinds use a dotted namespace prefix
+ *  (e.g. `'acme.Custom'`).
+ *
+ *  This function must be called explicitly — there is no implicit registration at
+ *  module load time. */
+export function registerParticleFormat(kind, codec) {
+    _registry.set(kind, codec);
+}
+/** Remove a previously registered format codec. Returns `true` if the kind was found
+ *  and removed, `false` if it was not registered. */
+export function unregisterParticleFormat(kind) {
+    return _registry.delete(kind);
+}
+// The format registry: last-write-wins per kind (matches the SDK's kind-registration pattern).
+const _registry = new Map();
+//# sourceMappingURL=formatRegistry.js.map

package/dist/formatRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatRegistry.js","sourceRoot":"","sources":["../src/formatRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAC;AA+BlE;;;;;;;yEAOyE;AACzE,MAAM,UAAU,8BAA8B,CAAC,IAAY;IACzD,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,SAAS,EAAE,CAAC;QACtC,IAAI,CAAC;YACH,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC;gBAAE,OAAO,IAAI,CAAC;QACtC,CAAC;QAAC,MAAM,CAAC;YACP,uDAAuD;QACzD,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,qFAAqF;AACrF,MAAM,UAAU,sBAAsB,CAAC,IAAwB;IAC7D,OAAO,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC;AACrC,CAAC;AAED,oDAAoD;AACpD,MAAM,UAAU,4BAA4B;IAC1C,OAAO,CAAC,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC,CAAC;AAC/B,CAAC;AAED;;;;oGAIoG;AACpG,MAAM,UAAU,6BAA6B,CAAC,IAAY,EAAE,IAAY;IACtE,MAAM,KAAK,GAAG,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAClC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO;YACL,MAAM,EAAE,2BAA2B,EAAE;YACrC,MAAM,EAAE,IAAI;YACZ,QAAQ,EAAE,CAAC,2BAA2B,IAAI,2BAA2B,CAAC;SACvE,CAAC;IACJ,CAAC;IACD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,CAAC;IAC5E,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO;YACL,MAAM,EAAE,2BAA2B,EAAE;YACrC,MAAM,EAAE,IAAI;YACZ,QAAQ,EAAE,CAAC,gBAAiB,GAAa,CAAC,OAAO,EAAE,CAAC;SACrD,CAAC;IACJ,CAAC;AACH,CAAC;AAED;;;;;;;;wBAQwB;AACxB,MAAM,UAAU,sBAAsB,CAAC,IAAwB,EAAE,KAA0B;IACzF,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AAC7B,CAAC;AAED;qDACqD;AACrD,MAAM,UAAU,wBAAwB,CAAC,IAAwB;IAC/D,OAAO,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAChC,CAAC;AAED,+FAA+F;AAC/F,MAAM,SAAS,GAAG,IAAI,GAAG,EAA+B,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export * from './detect';
+export * from './formatRegistry';
+export * from './libgdxParse';
+export * from './libgdxSchema';
+export * from './libgdxSerialize';
+export * from './parseParticleConfig';
+export * from './particleDesignerParse';
+export * from './particleDesignerSchema';
+export * from './particleDesignerSerialize';
+export * from './pixiParse';
+export * from './serializeResult';
+export * from './spineParse';
+export * from './spineSchema';
+export * from './spineSerialize';
+export * from './starlingPexParse';
+export * from './starlingPexSchema';
+export * from './starlingPexSerialize';
+export * from './unityParse';
+export * from './unitySchema';
+export * from './unitySerialize';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,21 @@
+export * from './detect';
+export * from './formatRegistry';
+export * from './libgdxParse';
+export * from './libgdxSchema';
+export * from './libgdxSerialize';
+export * from './parseParticleConfig';
+export * from './particleDesignerParse';
+export * from './particleDesignerSchema';
+export * from './particleDesignerSerialize';
+export * from './pixiParse';
+export * from './serializeResult';
+export * from './spineParse';
+export * from './spineSchema';
+export * from './spineSerialize';
+export * from './starlingPexParse';
+export * from './starlingPexSchema';
+export * from './starlingPexSerialize';
+export * from './unityParse';
+export * from './unitySchema';
+export * from './unitySerialize';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC"}

package/dist/libgdxParse.d.ts

@@ -0,0 +1,27 @@
+import type { ParticleEmitterConfig } from '@flighthq/types';
+import type { LibgdxParticleDocument } from './libgdxSchema';
+export interface LibgdxParseOptions {
+    /** Side length of the particle texture in pixels, used to normalise pixel sizes
+     *  to dimensionless scale multipliers. Defaults to 1 (no normalisation). */
+    textureSize?: number;
+}
+export interface LibgdxParseResult {
+    config: ParticleEmitterConfig;
+    document: LibgdxParticleDocument;
+    /** Features present in the source that the common-subset importer cannot
+     *  represent and silently dropped — surface these in your asset pipeline. */
+    warnings: string[];
+}
+/** @deprecated Use `LibgdxParseResult`. */
+export type LibgdxParsed = LibgdxParseResult;
+/** Parse a libGDX 2D Particle Editor `.p` file string directly to a ParticleEmitterConfig.
+ *
+ *  Single-pass: no intermediate document object is allocated.
+ *  Use `parseLibgdxParticleDocument` instead when you need round-trip serialisation.
+ *  Throws a clear, format-tagged error when the input cannot be parsed. */
+export declare function parseLibgdxParticle(text: string, options?: LibgdxParseOptions): ParticleEmitterConfig;
+/** Parse a libGDX 2D Particle Editor `.p` file string and preserve the full document
+ *  for round-trip serialisation via `serializeLibgdxParticle`.
+ *  Throws a clear, format-tagged error when the input cannot be parsed. */
+export declare function parseLibgdxParticleDocument(text: string, options?: LibgdxParseOptions): LibgdxParseResult;
+//# sourceMappingURL=libgdxParse.d.ts.map

package/dist/libgdxParse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"libgdxParse.d.ts","sourceRoot":"","sources":["../src/libgdxParse.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE7D,OAAO,KAAK,EAAE,sBAAsB,EAAoB,MAAM,gBAAgB,CAAC;AAE/E,MAAM,WAAW,kBAAkB;IACjC;gFAC4E;IAC5E,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,qBAAqB,CAAC;IAC9B,QAAQ,EAAE,sBAAsB,CAAC;IACjC;iFAC6E;IAC7E,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,2CAA2C;AAC3C,MAAM,MAAM,YAAY,GAAG,iBAAiB,CAAC;AAE7C;;;;2EAI2E;AAC3E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,qBAAqB,CAOrG;AAED;;2EAE2E;AAC3E,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,iBAAiB,CAYzG"}

package/dist/libgdxParse.js

@@ -0,0 +1,316 @@
+import { createParticleEmitterConfig } from '@flighthq/particles';
+/** Parse a libGDX 2D Particle Editor `.p` file string directly to a ParticleEmitterConfig.
+ *
+ *  Single-pass: no intermediate document object is allocated.
+ *  Use `parseLibgdxParticleDocument` instead when you need round-trip serialisation.
+ *  Throws a clear, format-tagged error when the input cannot be parsed. */
+export function parseLibgdxParticle(text, options) {
+    if (typeof text !== 'string' || !text.trim()) {
+        throw new Error('Invalid libGDX particle: input is empty or not a string');
+    }
+    const { sections } = parseLibgdxText(text);
+    const doc = sectionsToDocument(sections);
+    return documentToConfig(doc, options?.textureSize ?? 1);
+}
+/** Parse a libGDX 2D Particle Editor `.p` file string and preserve the full document
+ *  for round-trip serialisation via `serializeLibgdxParticle`.
+ *  Throws a clear, format-tagged error when the input cannot be parsed. */
+export function parseLibgdxParticleDocument(text, options) {
+    if (typeof text !== 'string' || !text.trim()) {
+        throw new Error('Invalid libGDX particle: input is empty or not a string');
+    }
+    const { sections } = parseLibgdxText(text);
+    const doc = sectionsToDocument(sections);
+    const textureSize = options?.textureSize ?? 1;
+    return {
+        config: documentToConfig(doc, textureSize),
+        document: doc,
+        warnings: collectLibgdxWarnings(doc),
+    };
+}
+const DEG2RAD = Math.PI / 180;
+function boolKey(section, key, def = false) {
+    const v = section.get(key);
+    if (v === undefined)
+        return def;
+    return v === 'true';
+}
+function collectLibgdxWarnings(doc) {
+    const warnings = [];
+    if (doc.delay.active)
+        warnings.push('libGDX emission delay is not supported and was ignored');
+    if (doc.lifeOffset.active)
+        warnings.push('libGDX lifeOffset is not supported and was ignored');
+    if (doc.xOffset.active || doc.yOffset.active) {
+        warnings.push('libGDX emitter x/y position offsets are not supported and were ignored');
+    }
+    if (doc.premultipliedAlpha) {
+        warnings.push('libGDX premultipliedAlpha flag is informational only; blending behavior may differ');
+    }
+    if (doc.spawnShape.shape === 'line') {
+        warnings.push('libGDX line spawn shape has no equivalent and was mapped to point emitter');
+    }
+    return warnings;
+}
+function documentToConfig(doc, textureSize) {
+    const [lifeMin, lifeMax] = rangeToMinMax(doc.life);
+    const [velMin, velMax] = doc.velocity.active ? rangeToMinMax(doc.velocity) : [0, 0];
+    const [angleMin, angleMax] = doc.angle.active ? rangeToMinMax(doc.angle) : [0, 360];
+    const angleMid = (angleMin + angleMax) * 0.5 * DEG2RAD;
+    const spread = (angleMax - angleMin) * 0.5 * DEG2RAD;
+    const [scaleMinPx, scaleMaxPx] = rangeToMinMax(doc.scale);
+    const scaleMin = scaleMinPx / textureSize;
+    const scaleMax = scaleMaxPx / textureSize;
+    // Scale end: use last scaling value (libGDX stores the scale curve as normalised scalings).
+    const lastScaling = doc.scale.scaling.length > 0 ? doc.scale.scaling[doc.scale.scaling.length - 1] : 1;
+    const scaleEnd = lastScaling;
+    const [windMin] = doc.wind.active ? rangeToMinMax(doc.wind) : [0, 0];
+    const [gravMin] = doc.gravity.active ? rangeToMinMax(doc.gravity) : [0, 0];
+    // Emitter spawn shape
+    const shape = doc.spawnShape.shape;
+    const [swMin, swMax] = rangeToMinMax(doc.spawnWidth);
+    const [shMin, shMax] = rangeToMinMax(doc.spawnHeight);
+    const swMid = (swMin + swMax) * 0.5;
+    const shMid = (shMin + shMax) * 0.5;
+    let emitterShape = 'point';
+    let emitterRadius = 0;
+    let emitterWidth = 0;
+    let emitterHeight = 0;
+    if (shape === 'ellipse') {
+        if (swMid > 0 && swMid === shMid) {
+            emitterShape = 'circle';
+            emitterRadius = swMid * 0.5;
+        }
+        else if (swMid > 0 || shMid > 0) {
+            emitterShape = 'rect';
+            emitterWidth = swMid;
+            emitterHeight = shMid;
+        }
+    }
+    else if (shape === 'square') {
+        emitterShape = 'rect';
+        emitterWidth = swMid;
+        emitterHeight = shMid;
+    }
+    // Colors: first and last tint entry
+    const firstColor = doc.tint.colors[0] ?? 'ffffff';
+    const lastColor = doc.tint.colors[doc.tint.colors.length - 1] ?? 'ffffff';
+    const [sr, sg, sb] = hexToRgb(firstColor);
+    const [er, eg, eb] = hexToRgb(lastColor);
+    // Alpha: first and last transparency scaling value
+    const alphaStart = doc.transparency.scaling[0] ?? 1;
+    const alphaEnd = doc.transparency.scaling[doc.transparency.scaling.length - 1] ?? 0;
+    // Duration: libGDX lowMin/lowMax is the constant range; use midpoint
+    const [durMin, durMax] = rangeToMinMax(doc.duration);
+    const durMid = (durMin + durMax) * 0.5;
+    // Rotation: libGDX stores angular velocity range
+    const [rotMin, rotMax] = doc.rotation.active ? rangeToMinMax(doc.rotation) : [0, 0];
+    const lifetimeMid = (lifeMin / 1000 + lifeMax / 1000) * 0.5 || 1;
+    const rotSpeedMin = (rotMin * DEG2RAD) / lifetimeMid;
+    const rotSpeedMax = (rotMax * DEG2RAD) / lifetimeMid;
+    const blendMode = doc.additive ? 'add' : 'normal';
+    return createParticleEmitterConfig({
+        maxParticles: doc.maxParticleCount,
+        loop: durMid <= 0,
+        duration: durMid > 0 ? durMid / 1000 : 0,
+        lifetimeMin: Math.max(0, lifeMin / 1000),
+        lifetimeMax: lifeMax / 1000,
+        speedMin: velMin,
+        speedMax: velMax,
+        directionX: Math.cos(angleMid),
+        directionY: -Math.sin(angleMid),
+        spread,
+        gravityX: windMin,
+        gravityY: gravMin,
+        emitterShape,
+        emitterRadius,
+        emitterWidth,
+        emitterHeight,
+        scaleMin,
+        scaleMax,
+        scaleEnd,
+        colorStartR: sr,
+        colorStartG: sg,
+        colorStartB: sb,
+        colorEndR: er,
+        colorEndG: eg,
+        colorEndB: eb,
+        alphaStart,
+        alphaEnd,
+        rotationSpeedMin: rotSpeedMin,
+        rotationSpeedMax: rotSpeedMax,
+        blendMode,
+    });
+}
+function hexToRgb(hex) {
+    const s = hex.replace(/^#/, '').padEnd(6, 'f');
+    const channel = (i) => {
+        const v = parseInt(s.slice(i, i + 2), 16);
+        return Number.isFinite(v) ? v / 255 : 1;
+    };
+    return [channel(0), channel(2), channel(4)];
+}
+function numKey(section, key, def = 0) {
+    const v = section.get(key);
+    if (v === undefined)
+        return def;
+    const n = parseFloat(v);
+    return Number.isFinite(n) ? n : def;
+}
+/** Parse the libGDX .p text format into a map of section → key/value pairs.
+ *
+ *  The format is a sequence of:
+ *    SectionName           (bare line, no colon)
+ *    key: value            (key/value pair belonging to the last section)
+ *
+ *  Scalar multi-value groups like `scalingCount: N / scaling0: v ... scalingN: v`
+ *  are read as individual keys; the caller assembles them into arrays. */
+function parseLibgdxText(text) {
+    const lines = text.split(/\r?\n/);
+    const sections = new Map();
+    let currentSection = '';
+    let current = new Map();
+    let header = '';
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (line === '' || line.startsWith('#'))
+            continue;
+        const colonIdx = line.indexOf(':');
+        if (colonIdx === -1) {
+            // Bare section name. "- Emitter -" or "SectionName" or file header.
+            if (currentSection !== '' || current.size > 0) {
+                sections.set(currentSection, current);
+            }
+            currentSection = line;
+            current = new Map();
+            if (header === '')
+                header = line;
+        }
+        else {
+            const key = line.slice(0, colonIdx).trim();
+            const value = line.slice(colonIdx + 1).trim();
+            current.set(key, value);
+        }
+    }
+    // Flush last section.
+    if (currentSection !== '' || current.size > 0) {
+        sections.set(currentSection, current);
+    }
+    return { header, sections };
+}
+function rangeToMinMax(r) {
+    // libGDX range: low end is lowMin..lowMax, high end is highMin..highMax.
+    // We take the midpoint of each end, then use low as min and high as max.
+    const lo = (r.lowMin + r.lowMax) * 0.5;
+    const hi = (r.highMin + r.highMax) * 0.5;
+    return [Math.min(lo, hi), Math.max(lo, hi)];
+}
+function readRange(section, def = {}) {
+    const count = numKey(section, 'scalingCount', 1) | 0;
+    const scaling = [];
+    const tlCount = numKey(section, 'timelineCount', 1) | 0;
+    const timeline = [];
+    for (let i = 0; i < count; i++)
+        scaling.push(numKey(section, `scaling${i}`, 1));
+    for (let i = 0; i < tlCount; i++)
+        timeline.push(numKey(section, `timeline${i}`, i === 0 ? 0 : 1));
+    return {
+        lowMin: numKey(section, 'lowMin', def.lowMin ?? 0),
+        lowMax: numKey(section, 'lowMax', def.lowMax ?? 0),
+        highMin: numKey(section, 'highMin', def.highMin ?? 0),
+        highMax: numKey(section, 'highMax', def.highMax ?? 0),
+        relative: boolKey(section, 'relative', false),
+        scaling,
+        timeline,
+    };
+}
+function sectionsToDocument(sections) {
+    // Find the emitter name: the "- Emitter -" section contains both the emitter name
+    // and the root metadata keys (maxParticleCount, additive, imagePath, etc.).
+    const emitterKey = [...sections.keys()].find((k) => k.startsWith('- ') && k.endsWith(' -'));
+    const emitterName = emitterKey?.slice(2, -2).trim() ?? '';
+    // Root keys (additive, maxParticleCount, imagePath) live in the emitter header section.
+    // Fall back to the empty-key section for files that don't use the "- Name -" form.
+    const root = (emitterKey !== undefined ? sections.get(emitterKey) : null) ??
+        sections.get('Particle Effect') ??
+        sections.get('') ??
+        new Map();
+    const get = (name) => sections.get(name) ?? new Map();
+    const delaySection = get('Delay');
+    const durationSection = get('Duration');
+    const emissionSection = get('Emission');
+    const lifeSection = get('Life');
+    const lifeOffsetSection = get('Life Offset');
+    const xOffSection = get('X Offset');
+    const yOffSection = get('Y Offset');
+    const spawnShapeSection = get('Spawn Shape');
+    const spawnWidthSection = get('Spawn Width');
+    const spawnHeightSection = get('Spawn Height');
+    const scaleSection = get('Scale');
+    const velocitySection = get('Velocity');
+    const angleSection = get('Angle');
+    const rotationSection = get('Rotation');
+    const windSection = get('Wind');
+    const gravitySection = get('Gravity');
+    const tintSection = get('Tint');
+    const transparencySection = get('Transparency');
+    // Tint colors are stored as a comma-separated hex string and a timeline.
+    const tintColors = [];
+    const tintTimeline = [];
+    const rawColors = strKey(tintSection, 'colors', '');
+    if (rawColors) {
+        rawColors.split(',').forEach((c) => {
+            const trimmed = c.trim();
+            if (trimmed)
+                tintColors.push(trimmed);
+        });
+    }
+    if (tintColors.length === 0)
+        tintColors.push('ffffff');
+    const tintTlCount = numKey(tintSection, 'timelineCount', 1) | 0 || 1;
+    for (let i = 0; i < tintTlCount; i++)
+        tintTimeline.push(numKey(tintSection, `timeline${i}`, i === 0 ? 0 : 1));
+    const shapeStr = strKey(spawnShapeSection, 'shape', 'point');
+    const spawnShape = {
+        shape: (shapeStr === 'line' || shapeStr === 'square' || shapeStr === 'ellipse' ? shapeStr : 'point'),
+        edges: boolKey(spawnShapeSection, 'edges', false),
+        side: (strKey(spawnShapeSection, 'side', 'both') || 'both'),
+    };
+    return {
+        name: emitterName,
+        minParticleCount: numKey(root, 'minParticleCount', 4),
+        maxParticleCount: numKey(root, 'maxParticleCount', 100),
+        additive: boolKey(root, 'additive', false),
+        premultipliedAlpha: boolKey(root, 'premultipliedAlpha', false),
+        delay: { active: boolKey(delaySection, 'active', false), ...readRange(delaySection) },
+        duration: readRange(durationSection, { lowMin: 3000, lowMax: 3000 }),
+        emission: readRange(emissionSection, { highMin: 32, highMax: 64 }),
+        life: readRange(lifeSection, { lowMin: 1000, lowMax: 1000 }),
+        lifeOffset: { active: boolKey(lifeOffsetSection, 'active', false), ...readRange(lifeOffsetSection) },
+        xOffset: { active: boolKey(xOffSection, 'active', false), ...readRange(xOffSection) },
+        yOffset: { active: boolKey(yOffSection, 'active', false), ...readRange(yOffSection) },
+        spawnShape,
+        spawnWidth: readRange(spawnWidthSection),
+        spawnHeight: readRange(spawnHeightSection),
+        scale: readRange(scaleSection, { highMin: 32, highMax: 32 }),
+        velocity: {
+            active: boolKey(velocitySection, 'active', true),
+            ...readRange(velocitySection, { highMin: 100, highMax: 100 }),
+        },
+        angle: {
+            active: boolKey(angleSection, 'active', true),
+            ...readRange(angleSection, { highMin: 360, highMax: 360 }),
+        },
+        rotation: { active: boolKey(rotationSection, 'active', false), ...readRange(rotationSection) },
+        wind: { active: boolKey(windSection, 'active', false), ...readRange(windSection) },
+        gravity: { active: boolKey(gravitySection, 'active', false), ...readRange(gravitySection) },
+        tint: { colors: tintColors, timeline: tintTimeline },
+        transparency: readRange(transparencySection, { highMin: 1, highMax: 1 }),
+        imageCount: numKey(root, 'imageCount', 1),
+        imagePath: strKey(root, 'imagePath', ''),
+    };
+}
+function strKey(section, key, def = '') {
+    return section.get(key) ?? def;
+}
+//# sourceMappingURL=libgdxParse.js.map