@intelligentgraphics/ig.gfx.packager 3.0.17 → 3.0.19

package/lib/lib.mjs

@@ -56,10 +56,10 @@ const PACKAGE_FILE = "_Package.json";
 const INDEX_FILE = "_Index.json";
 const ANIMATION_FILE_SUFFIX = ".animation.json";
 const parseCreatorPackageName = (manifest)=>{
-    const [domain, ...subdomainParts] = manifest.Package.split(".");
+    const [domain, subdomain] = manifest.Package.split(".");
     return {
         domain,
-        subdomain: subdomainParts.join(".")
+        subdomain
     };
 };
 const readPackageCreatorManifest = (location)=>{
@@ -496,16 +496,342 @@ const toposort = (packages)=>{
     return result;
 };
 
+var animationSchema = {
+    $schema: "http://json-schema.org/draft-07/schema",
+    $id: "https://archive.intelligentgraphics.biz/schemas/gfx/animation.json",
+    $comment: "Version 2023-02-17, Source: ig.data.gfx/Specs/animation.json",
+    title: "Animation description format",
+    additionalProperties: false,
+    type: "object",
+    properties: {
+        $schema: {
+            type: "string"
+        },
+        Id: {
+            type: "string",
+            description: "Animation id, to be unique in the project scope. Needs to be a valid JavaScript identifier."
+        },
+        Animations: {
+            type: "array",
+            description: "Declaration of animation states for gfx objects",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    _: {
+                        type: "string",
+                        description: "Comment"
+                    },
+                    Path: {
+                        $ref: "#/definitions/igxcPath"
+                    },
+                    States: {
+                        type: "object",
+                        additionalProperties: {
+                            type: "object",
+                            additionalProperties: false,
+                            properties: {
+                                Position: {
+                                    $ref: "#/definitions/vec3"
+                                },
+                                Rotation: {
+                                    $ref: "#/definitions/rotation"
+                                },
+                                Scaling: {
+                                    $ref: "#/definitions/vec3"
+                                },
+                                Visibility: {
+                                    type: "boolean"
+                                },
+                                Deformation: {
+                                    anyOf: [
+                                        {
+                                            type: "number"
+                                        },
+                                        {
+                                            type: "string"
+                                        }
+                                    ]
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        Kinematics: {
+            oneOf: [
+                {
+                    $ref: "#/definitions/kinematicChain"
+                },
+                {
+                    type: "array",
+                    items: {
+                        $ref: "#/definitions/kinematicChain"
+                    }
+                }
+            ]
+        },
+        LinkedPoints: {
+            type: "object",
+            additionalProperties: {
+                type: "array",
+                items: {
+                    type: "string"
+                }
+            }
+        },
+        _: {
+            type: "string",
+            description: "Comment"
+        }
+    },
+    definitions: {
+        vec3: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                X: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                Y: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                Z: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                _: {
+                    type: "string",
+                    description: "Comment"
+                }
+            }
+        },
+        rotation: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                Q: {
+                    description: "If true, the rotation is considered to be a Quaternion. Otherwise, it's interpreted as Euler arcs and W will be ignored.",
+                    type: "boolean"
+                },
+                X: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                Y: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                Z: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                W: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                _: {
+                    type: "string",
+                    description: "Comment"
+                }
+            }
+        },
+        igxcPath: {
+            type: "string",
+            description: "Relative path of the target object",
+            pattern: "^((o|e)\\d+(\\.(o|e)\\d+)*|\\.)$"
+        },
+        param: {
+            type: "string",
+            pattern: "^Param\\d+$"
+        },
+        kinematicChain: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                GeometryBase: {
+                    type: "string"
+                },
+                Joints: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            Name: {
+                                oneOf: [
+                                    {
+                                        $ref: "#/definitions/param"
+                                    },
+                                    {
+                                        type: "string"
+                                    }
+                                ]
+                            },
+                            HeadX: {
+                                oneOf: [
+                                    {
+                                        $ref: "#/definitions/param"
+                                    },
+                                    {
+                                        $ref: "#/definitions/igxcPath"
+                                    }
+                                ]
+                            },
+                            HeadY: {
+                                oneOf: [
+                                    {
+                                        $ref: "#/definitions/param"
+                                    },
+                                    {
+                                        $ref: "#/definitions/igxcPath"
+                                    }
+                                ]
+                            },
+                            HeadZ: {
+                                oneOf: [
+                                    {
+                                        $ref: "#/definitions/param"
+                                    },
+                                    {
+                                        $ref: "#/definitions/igxcPath"
+                                    }
+                                ]
+                            },
+                            Tail: {
+                                oneOf: [
+                                    {
+                                        $ref: "#/definitions/param"
+                                    },
+                                    {
+                                        $ref: "#/definitions/igxcPath"
+                                    }
+                                ]
+                            },
+                            LimitLeft: {
+                                type: "number"
+                            },
+                            LimitRight: {
+                                type: "number"
+                            },
+                            LimitUp: {
+                                type: "number"
+                            },
+                            LimitDown: {
+                                type: "number"
+                            },
+                            FollowJointNode: {
+                                $ref: "#/definitions/igxcPath"
+                            },
+                            _TargetNodeForFollow: {
+                                type: "string"
+                            }
+                        }
+                    }
+                },
+                Target: {
+                    oneOf: [
+                        {
+                            $ref: "#/definitions/igxcPath"
+                        },
+                        {
+                            $ref: "#/definitions/param"
+                        },
+                        {
+                            type: "string",
+                            enum: [
+                                "subbase"
+                            ]
+                        }
+                    ]
+                },
+                Parent: {
+                    oneOf: [
+                        {
+                            $ref: "#/definitions/igxcPath"
+                        },
+                        {
+                            type: "string",
+                            enum: [
+                                "root"
+                            ]
+                        }
+                    ]
+                },
+                Tolerance: {
+                    type: "number"
+                },
+                MaxIterations: {
+                    type: "integer"
+                },
+                _: {
+                    type: "string",
+                    description: "Comment"
+                },
+                __: {
+                    type: "string",
+                    description: "Super Comment"
+                }
+            }
+        }
+    }
+};
+
 let validateAnimationJson;
 const getAnimationJsonValidation = async ()=>{
     if (validateAnimationJson === undefined) {
-        validateAnimationJson = await axios.get("https://archive.intelligentgraphics.biz/schemas/gfx/animation.json").then(({ data  })=>new Ajv({
-                coerceTypes: true,
-                allErrors: true,
-                removeAdditional: true,
-                useDefaults: "empty",
-                validateSchema: "log"
-            }).compile(data));
+        validateAnimationJson = new Ajv({
+            coerceTypes: true,
+            allErrors: true,
+            removeAdditional: true,
+            useDefaults: "empty",
+            validateSchema: "log"
+        }).compile(animationSchema);
     }
     return validateAnimationJson;
 };
@@ -1095,14 +1421,14 @@ const notRuntimeScripts = [
     "Evaluator"
 ];
 const buildArchiveFromPackage = async (packageLocation, data, binDir)=>{
-    const { domain , subdomain  } = parseCreatorPackageName(data);
+    const { domain  } = parseCreatorPackageName(data);
     const logStep = (step)=>logPackageMessage(data.Package, step);
     const libFilePath = path.join(binDir, `${data.Package}.min.js`);
     const scriptDirectories = [
         packageLocation.path,
         packageLocation.scriptsDir
     ];
-    if (subdomain === "GFX.Standard") {
+    if (data.Package === "IG.GFX.Standard") {
         logStep(`Including Images folder`);
         scriptDirectories.push(path.join(packageLocation.path, "Images"));
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@intelligentgraphics/ig.gfx.packager",
-  "version": "3.0.17",
-  "description": "IG.GFX.Packager 3.0.17 (3.0.17.100)",
+  "version": "3.0.19",
+  "description": "IG.GFX.Packager 3.0.19 (3.0.19.100)",
   "author": "Michael Beier <mb@intelligentgraphics.biz>",
   "main": "lib/lib.mjs",
   "types": "lib/lib.d.ts",

package/readme.md

@@ -470,6 +470,14 @@ Afterwards you may need to reload your editor in order for the installed files t
 
 ## History
 
+**IG.GFX.Packager 3.0.19**
+
+-   when parsing the package name as upload domain and sub domain, only use the first two parts that are separated by dots and ignore the rest -> IG.GFX.Standard -> Domain IG, SubDomain GFX
+
+**IG.GFX.Packager 3.0.18**
+
+-   add animation json schema to own files and no longer load it from archive
+
 **IG.GFX.Packager 3.0.17**
 
 -   use provided bin dir