@intelligentgraphics/ig.gfx.packager 3.0.11 → 3.0.13

package/lib/lib.mjs

@@ -8,10 +8,10 @@ import 'write-json-file';
 import axios from 'axios';
 import ts from 'typescript';
 import typedoc from 'typedoc';
+import Ajv from 'ajv';
 import { pipeline } from 'stream/promises';
 import { execSync } from 'child_process';
 import simpleGit from 'simple-git';
-import Ajv from 'ajv';
 import JSZip from 'jszip';
 
 const stripUtf8Bom = (text)=>{
@@ -79,6 +79,10 @@ const readPackageCreatorIndex = (location)=>{
         throw err;
     }
 };
+const writePackageCreatorIndex = (location, index)=>{
+    const indexPath = getPackageCreatorIndexPath(location);
+    fs.writeFileSync(indexPath, JSON.stringify(index, null, "\t") + "\n");
+};
 const readPackageNpmManifest = (location)=>{
     try {
         return readNpmManifest(location.manifestDir);
@@ -495,6 +499,19 @@ const toposort = (packages)=>{
     return result;
 };
 
+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));
+    }
+    return validateAnimationJson;
+};
 const buildFolders = async (options)=>{
     if (options.outDir !== undefined && options.clean) {
         fs.rmSync(options.outDir, {
@@ -504,31 +521,71 @@ const buildFolders = async (options)=>{
     const workspace = options.workspace;
     const folders = options.packages;
     let sortedPackages = sortPackagesByBuildOrder(folders);
-    if (options.skipPackagesWithoutTsFiles) {
-        sortedPackages = sortedPackages.filter((location)=>getPackageTypescriptFiles(location).length > 0);
-    }
     let index = 1;
     for (const location of sortedPackages){
+        const hasTypescript = getPackageTypescriptFiles(location).length > 0;
         ensureTsConfig(location);
         const data = readPackageCreatorManifest(location);
         const logStep = (step)=>logPackageMessage(data.Package, step, index, folders.length);
-        logStep("Compiling typescript to javascript");
         const outputDirectory = options.outDir || location.scriptsDir;
         fs.mkdirSync(outputDirectory, {
             recursive: true
         });
-        const buildResult = await build(location, outputDirectory);
+        let buildResult;
+        if (hasTypescript) {
+            logStep("Compiling typescript to javascript");
+            buildResult = await build(location, outputDirectory);
+        } else {
+            buildResult = {
+                js: ""
+            };
+        }
         const banner = options.banner ? createBannerComment(options.banner) : undefined;
         if (banner) {
             buildResult.js = banner + "\n" + buildResult.js;
-            buildResult.definitions = banner + "\n" + buildResult.definitions;
+            if (buildResult.definitions !== undefined) {
+                buildResult.definitions = banner + "\n" + buildResult.definitions;
+            }
+        }
+        const animations = new Map();
+        for (const scriptFilePath of readPackageAnimationList(location)){
+            const content = fs.readFileSync(scriptFilePath, {
+                encoding: "utf8"
+            });
+            let data;
+            try {
+                data = JSON.parse(content);
+            } catch (err) {
+                const relativePath = path.relative(options.workspace.path, scriptFilePath);
+                if (err instanceof SyntaxError) {
+                    throw new Error(`Encountered invalid syntax in file "${relativePath}": ${String(err)}`);
+                }
+                throw new Error(`Encountered an unexpected error while parsing animation json file at path "${relativePath}"`, {
+                    cause: err
+                });
+            }
+            (await getAnimationJsonValidation())(data);
+            animations.set(data.Id, JSON.stringify(data));
+        }
+        if (animations.size > 0) {
+            const scope = data.Scope ?? data.Package;
+            const scopeParts = scope.split(".");
+            buildResult.js += createNamespace(scopeParts);
+            for (const [name, content] of animations){
+                buildResult.js += `${scope}["${name}"] = ` + content + ";";
+                logPackageMessage(data.Package, `Adding animation ${scope}.${name}`);
+            }
+        } else if (!hasTypescript) {
+            throw new Error(`Expected package to have a least one ts file or one animation.json file`);
         }
         fs.writeFileSync(path.join(outputDirectory, `${data.Package}.js`), buildResult.js, {
             encoding: "utf8"
         });
-        fs.writeFileSync(path.join(outputDirectory, `${data.Package}.d.ts`), buildResult.definitions, {
-            encoding: "utf8"
-        });
+        if (buildResult.definitions !== undefined) {
+            fs.writeFileSync(path.join(outputDirectory, `${data.Package}.d.ts`), buildResult.definitions, {
+                encoding: "utf8"
+            });
+        }
         if (options.minimize) {
             const minifyResult = await terser.minify(buildResult.js, {
                 ecma: 5
@@ -538,7 +595,7 @@ const buildFolders = async (options)=>{
                 encoding: "utf8"
             });
         }
-        if (location.path.includes("Basics")) {
+        if (location.path.includes("Basics") && buildResult.definitions !== undefined) {
             fs.mkdirSync(path.join(workspace.path, "lib"), {
                 recursive: true
             });
@@ -554,6 +611,14 @@ const buildFolders = async (options)=>{
         index++;
     }
 };
+const createNamespace = (parts)=>{
+    let code = `var ${parts[0]};`;
+    for(let index = 0; index < parts.length; index++){
+        const path = parts.slice(0, index + 1).join(".");
+        code += `\n(${path} = ${path} || {});`;
+    }
+    return code;
+};
 const ensureTsConfig = (location)=>{
     const tsconfigPath = path.join(location.scriptsDir, "tsconfig.json");
     if (!fs.existsSync(tsconfigPath)) {
@@ -1018,7 +1083,6 @@ const buildArchiveFromPublishedPackage = (location, manifest, creatorPackage)=>{
     archive.file(manifest.main, fs.createReadStream(path.join(location.path, manifest.main)));
     return archive;
 };
-let validateSchema;
 const runtimeScripts = [
     "Interactor",
     "Core",
@@ -1031,15 +1095,6 @@ const notRuntimeScripts = [
 const buildArchiveFromPackage = async (workspaceLocation, packageLocation, data)=>{
     const { domain , subdomain  } = parseCreatorPackageName(data);
     const logStep = (step)=>logPackageMessage(data.Package, step);
-    if (validateSchema === undefined) {
-        validateSchema = 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));
-    }
     const libFilePath = path.join(getWorkspaceOutputPath(workspaceLocation), `${data.Package}.min.js`);
     const scriptDirectories = [
         packageLocation.path,
@@ -1065,31 +1120,6 @@ const buildArchiveFromPackage = async (workspaceLocation, packageLocation, data)
             });
         }
     }
-    // if (index === undefined) {
-    // 	throw new Error(
-    // 		`Could not find an "${INDEX_FILE}" file in "${primaryScriptDir}"`,
-    // 	);
-    // }
-    const animations = new Map();
-    for (const scriptFilePath of readPackageAnimationList(packageLocation)){
-        const content = fs.readFileSync(scriptFilePath, {
-            encoding: "utf8"
-        });
-        let data;
-        try {
-            data = JSON.parse(content);
-        } catch (err) {
-            const relativePath = path.relative(workspaceLocation.path, scriptFilePath);
-            if (err instanceof SyntaxError) {
-                throw new Error(`Encountered invalid syntax in file "${relativePath}": ${String(err)}`);
-            }
-            throw new Error(`Encountered an unexpected error while parsing animation json file at path "${relativePath}"`, {
-                cause: err
-            });
-        }
-        validateSchema(data);
-        animations.set(data.Id, JSON.stringify(data));
-    }
     let libFile;
     try {
         libFile = fs.readFileSync(libFilePath, {
@@ -1100,12 +1130,6 @@ const buildArchiveFromPackage = async (workspaceLocation, packageLocation, data)
             throw err;
         }
     }
-    if (libFile === undefined) {
-        if (animations.size === 0) {
-            throw new Error(`Could not find a javascript file at "${libFilePath}".
-Packaging without a javascript file is only allowed when animation json files are available`);
-        }
-    }
     const archive = new JSZip();
     let library = "";
     if (libFile) {
@@ -1116,15 +1140,6 @@ Packaging without a javascript file is only allowed when animation json files ar
         library = `/* This file is part of the ${domain} Data Packages.
 		* Copyright (C) ${date.getFullYear()} intelligentgraphics. All Rights Reserved. */`;
     }
-    if (animations.size > 0) {
-        const scope = data.Scope ?? data.Package;
-        const scopeParts = scope.split(".");
-        library += createNamespace(scopeParts);
-        for (const [name, data] of animations){
-            library += `${scope}.${name} = ` + data + ";";
-            logPackageMessage(manifest.Package, `Added animation ${scope}.${name}`);
-        }
-    }
     const minifyResult = await terser.minify(library, {
         ecma: 5
     });
@@ -1154,14 +1169,6 @@ Packaging without a javascript file is only allowed when animation json files ar
     }
     return archive;
 };
-const createNamespace = (parts)=>{
-    let code = `var ${parts[0]};`;
-    for(let index = 0; index < parts.length; index++){
-        const path = parts.slice(0, index + 1).join(".");
-        code += `\n(${path} = ${path} || {});`;
-    }
-    return code;
-};
 
 const releaseFolder = async (options)=>{
     const workspace = options.workspace;
@@ -1234,7 +1241,6 @@ const releaseFolder = async (options)=>{
                 packages: [
                     location
                 ],
-                skipPackagesWithoutTsFiles: true,
                 banner: options.banner ? {
                     text: bannerText,
                     commit: gitVersionInformation.commit,
@@ -1257,7 +1263,7 @@ const releaseFolder = async (options)=>{
                 var _workspaceManifest_dependencies;
                 const workspaceManifest = readWorkspaceNpmManifest(workspace);
                 if (!((_workspaceManifest_dependencies = workspaceManifest.dependencies) == null ? void 0 : _workspaceManifest_dependencies["@intelligentgraphics/3d.ig.gfx.standard"])) {
-                    const install = await options.prompter.confirm(`Animation.json files require the library 'IG.GFX.Standard' to be available, but it is not registered as a dependency. Do you want to install it now?`);
+                    const install = await options.prompter.confirm(`Animation.json files expect the library 'IG.GFX.Standard' to be available, but it is not registered as a dependency. Do you want it to be added now?`);
                     if (install) {
                         execSync(`npm install @intelligentgraphics/3d.ig.gfx.standard`, {
                             encoding: "utf-8",
@@ -1472,5 +1478,279 @@ const createSessionManager = async (params)=>{
     };
 };
 
-export { buildFolders, releaseFolder };
+/**
+ * Extracts and returns script array for _Index.json from a src folder
+ *
+ * @param folderPath path to a src folder
+ */ function generateIndex({ location , ignore =[] , strictOptional =false  }) {
+    const files = getPackageTypescriptFiles(location);
+    const filtered = files.filter((path)=>{
+        return !ignore.some((suffix)=>path.endsWith(suffix));
+    });
+    const arr = [];
+    const existingIndex = readPackageCreatorIndex(location) ?? [];
+    const program = ts.createProgram(filtered, {
+        allowJs: true
+    });
+    const typeChecker = program.getTypeChecker();
+    filtered.forEach((file)=>{
+        // Create a Program to represent the project, then pull out the
+        // source file to parse its AST.
+        const sourceFile = program.getSourceFile(file);
+        // Loop through the root AST nodes of the file
+        ts.forEachChild(sourceFile, (node)=>{
+            for (const scriptingClass of findScriptingClasses(node)){
+                if (scriptingClass.node.name === undefined) {
+                    throw new Error(`Expected ${scriptingClass.type} class to have a name`);
+                }
+                const name = typeChecker.getFullyQualifiedName(typeChecker.getSymbolAtLocation(scriptingClass.node.name));
+                if (name.length > 45) {
+                    throw new Error(`Package name length >45 '${name}'`);
+                }
+                const parameterDeclaration = getScriptingClassParameterdeclaration(scriptingClass);
+                const parametersType = parameterDeclaration === undefined ? undefined : typeChecker.getTypeAtLocation(parameterDeclaration);
+                if (parametersType === undefined) {
+                    console.log(`Failed to find parameters type declaration for ${scriptingClass.type} ${name}. Skipping parameter list generation`);
+                }
+                const existingIndexEntry = existingIndex.find((entry)=>entry.Name === name);
+                const obj = {
+                    Name: name,
+                    Description: (existingIndexEntry == null ? void 0 : existingIndexEntry.Description) ?? name,
+                    Type: scriptingClass.type === "evaluator" ? "Evaluator" : "Interactor",
+                    Parameters: []
+                };
+                const rawDocTags = ts.getJSDocTags(scriptingClass.node);
+                const dict = getTagDict(rawDocTags);
+                if (dict.summary) {
+                    obj.Description = dict.summary;
+                } else {
+                    const comment = typeChecker.getTypeAtLocation(scriptingClass.node).symbol.getDocumentationComment(typeChecker).map((comment)=>comment.text).join(" ");
+                    if (comment) {
+                        obj.Description = comment;
+                    }
+                }
+                if (parametersType !== undefined) {
+                    obj.Parameters = parseParametersList(typeChecker.getPropertiesOfType(parametersType), strictOptional);
+                    if (obj.Parameters.length === 0 && parametersType.getStringIndexType() !== undefined) {
+                        obj.Parameters = (existingIndexEntry == null ? void 0 : existingIndexEntry.Parameters) ?? [];
+                    }
+                } else if (existingIndexEntry !== undefined) {
+                    obj.Parameters = existingIndexEntry.Parameters;
+                }
+                arr.push(obj);
+            }
+        });
+    });
+    arr.sort((a, b)=>a.Name.localeCompare(b.Name));
+    writePackageCreatorIndex(location, arr);
+}
+function capitalizeFirstLetter(string) {
+    return (string == null ? void 0 : string.charAt(0).toUpperCase()) + (string == null ? void 0 : string.slice(1));
+}
+const parseDefault = (value, type)=>{
+    const uType = capitalizeFirstLetter(type);
+    if (value === "null") return null;
+    switch(uType){
+        case "LengthM":
+        case "ArcDEG":
+        case "Float":
+            return parseFloat(value);
+        case "Integer":
+        case "Int":
+            return parseInt(value);
+        case "Boolean":
+        case "Bool":
+            return value === "true";
+        case "Material":
+        case "String":
+        case "Geometry":
+        default:
+            return value.replace(/^"/, "").replace(/"$/, "");
+    }
+};
+const parseTypeFromName = (name)=>{
+    const parts = name.split(".");
+    const identifier = parts[parts.length - 1];
+    switch(identifier){
+        case "LengthM":
+        case "ArcDEG":
+        case "Float":
+        case "Integer":
+            return identifier;
+        case "GeometryReference":
+            return "Geometry";
+        case "MaterialReference":
+            return "Material";
+        case "AnimationReference":
+            return "Animation";
+        case "InteractorReference":
+            return "Interactor";
+        case "EvaluatorReference":
+            return "Evaluator";
+        case "String":
+        case "string":
+            return "String";
+        case "number":
+        case "Number":
+            return "Float";
+        case "boolean":
+        case "Boolean":
+            return "Boolean";
+    }
+};
+const parseParametersList = (properties, strictOptional)=>{
+    return properties.map((symbol, i)=>{
+        var _symbol_getDeclarations;
+        const parameter = {
+            Name: symbol.name,
+            Description: undefined,
+            Type: "String",
+            Default: undefined,
+            DisplayIndex: i + 1
+        };
+        if (parameter.Name.length > 45) {
+            throw new Error(`Parameter name length >45 '${parameter.Name}'`);
+        }
+        let declaration = (_symbol_getDeclarations = symbol.getDeclarations()) == null ? void 0 : _symbol_getDeclarations[0];
+        let documentationComment = symbol.getDocumentationComment(undefined);
+        let checkLinksSymbol = symbol;
+        while(checkLinksSymbol !== undefined && declaration === undefined){
+            const links = checkLinksSymbol.links;
+            if (links == null ? void 0 : links.syntheticOrigin) {
+                var _links_syntheticOrigin_getDeclarations;
+                declaration = (_links_syntheticOrigin_getDeclarations = links.syntheticOrigin.getDeclarations()) == null ? void 0 : _links_syntheticOrigin_getDeclarations[0];
+                if (documentationComment.length === 0) {
+                    documentationComment = links.syntheticOrigin.getDocumentationComment(undefined);
+                }
+                checkLinksSymbol = links.syntheticOrigin;
+            }
+        }
+        if (declaration !== undefined) {
+            const rawDocTags = ts.getJSDocTags(declaration);
+            const dict = getTagDict(rawDocTags);
+            if (dict.summary) {
+                parameter.Description = dict.summary;
+            } else {
+                const comment = documentationComment.map((comment)=>comment.text).join(" ");
+                if (comment) {
+                    parameter.Description = comment;
+                }
+            }
+            if (dict.creatorType) {
+                parameter.Type = dict.creatorType;
+            } else {
+                const propertySignature = declaration;
+                if (propertySignature.type !== undefined) {
+                    const parsedType = parseTypeFromName(propertySignature.type.getText());
+                    if (parsedType !== undefined) {
+                        parameter.Type = parsedType;
+                    }
+                }
+            }
+            if (dict.default) {
+                parameter.Default = parseDefault(dict.default, parameter.Type);
+            }
+            if (strictOptional && declaration.kind === ts.SyntaxKind.PropertySignature) {
+                const propertySignature = declaration;
+                if (propertySignature.questionToken === undefined) {
+                    parameter.Required = true;
+                }
+            }
+        }
+        return parameter;
+    });
+};
+function getTagDict(tags) {
+    const dict = {};
+    for (const tag of tags){
+        dict[tag.tagName.text] = tag.comment;
+    }
+    return dict;
+}
+const getScriptingClassParameterdeclaration = (scriptingClass)=>{
+    for (const member of scriptingClass.node.members){
+        if (ts.isMethodDeclaration(member)) {
+            for(let index = 0; index < member.parameters.length; index++){
+                const parameter = member.parameters[index];
+                if (isScriptingClassParameterDeclaration(scriptingClass, member, index)) {
+                    return parameter;
+                }
+            }
+        }
+        if (ts.isConstructorDeclaration(member)) {
+            for(let index = 0; index < member.parameters.length; index++){
+                const parameter = member.parameters[index];
+                if (isScriptingClassParameterDeclaration(scriptingClass, member, index)) {
+                    return parameter;
+                }
+            }
+        }
+    }
+};
+const isScriptingClassParameterDeclaration = (scriptingClass, memberNode, parameterIndex)=>{
+    if (scriptingClass.type === "evaluator") {
+        var _memberNode_name;
+        return (memberNode == null ? void 0 : (_memberNode_name = memberNode.name) == null ? void 0 : _memberNode_name.getText()) == "Create" && parameterIndex === 2;
+    }
+    if (scriptingClass.type === "interactor") {
+        return memberNode.kind === ts.SyntaxKind.Constructor && parameterIndex === 0;
+    }
+    return false;
+};
+/**
+ * Finds interactors and evaluators within a script file
+ *
+ * @param {ts.Node} node
+ * @return {*}
+ */ const findScriptingClasses = (node)=>{
+    let body;
+    if (ts.isModuleDeclaration(node)) {
+        body = node.body;
+    }
+    if (body !== undefined && ts.isModuleDeclaration(body)) {
+        body = body.body;
+    }
+    const classes = [];
+    if (body !== undefined) {
+        ts.forEachChild(body, (child)=>{
+            if (!ts.isClassDeclaration(child)) {
+                return;
+            }
+            const scriptingClass = detectScriptingClass(child);
+            if (scriptingClass !== undefined) {
+                classes.push(scriptingClass);
+            }
+        });
+    }
+    return classes;
+};
+const detectScriptingClass = (node)=>{
+    var _node_heritageClauses, _node_heritageClauses1;
+    const isEvaluator = (_node_heritageClauses = node.heritageClauses) == null ? void 0 : _node_heritageClauses.some((clause)=>{
+        if (clause.token !== ts.SyntaxKind.ExtendsKeyword && clause.token !== ts.SyntaxKind.ImplementsKeyword) {
+            return false;
+        }
+        return clause.types.some((type)=>type.getText().includes("Evaluator"));
+    });
+    if (isEvaluator) {
+        return {
+            node,
+            type: "evaluator"
+        };
+    }
+    const isInteractor = (_node_heritageClauses1 = node.heritageClauses) == null ? void 0 : _node_heritageClauses1.some((clause)=>{
+        if (clause.token !== ts.SyntaxKind.ExtendsKeyword) {
+            return false;
+        }
+        return clause.types.some((type)=>type.getText().includes("Interactor"));
+    });
+    if (isInteractor) {
+        return {
+            node,
+            type: "interactor"
+        };
+    }
+};
+
+export { buildFolders, generateIndex, releaseFolder };
 //# sourceMappingURL=lib.mjs.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@intelligentgraphics/ig.gfx.packager",
-  "version": "3.0.11",
-  "description": "IG.GFX.Packager 3.0.11 (3.0.11.100)",
+  "version": "3.0.13",
+  "description": "IG.GFX.Packager 3.0.13 (3.0.13.100)",
   "author": "Michael Beier <mb@intelligentgraphics.biz>",
   "main": "lib/lib.mjs",
   "types": "lib/lib.d.ts",
@@ -42,8 +42,8 @@
     "simple-git": "^3.16.0",
     "source-map-support": "^0.5.21",
     "terser": "^5.16.1",
-    "typedoc": "~0.23.2",
-    "typescript": "~5.0.2",
+    "typedoc": "^0.24.8",
+    "typescript": "^5.1.6",
     "update-notifier": "^6.0.2",
     "v8-compile-cache": "^2.3.0",
     "write-pkg": "^5.1.0",

package/readme.md

@@ -470,6 +470,17 @@ Afterwards you may need to reload your editor in order for the installed files t
 
 ## History
 
+**IG.GFX.Packager 3.0.13**
+
+-   update typescript and typedoc
+-   refactor to bundle animations as part of build
+
+**IG.GFX.Packager 3.0.12**
+
+-   handle animation json ids that are not valid js identifiers
+-   default creator index entry description to name
+-   update typescript
+
 **IG.GFX.Packager 3.0.11**
 
 -   add library distribution