@markw65/monkeyc-optimizer 1.0.10 → 1.0.13

package/build/src/optimizer.d.ts

@@ -0,0 +1,185 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { get_jungle, ResolvedJungle, Target } from "./jungles";
+import { launchSimulator, simulateProgram } from "./launch";
+import { manifestProducts } from "./manifest";
+import { copyRecursiveAsNeeded } from "./util";
+export { copyRecursiveAsNeeded, get_jungle, launchSimulator, manifestProducts, mctree, ResolvedJungle, simulateProgram, };
+export declare const defaultConfig: {
+    outputPath: string;
+    workspace: string;
+};
+export interface ErrorWithLocation extends Error {
+    location?: NonNullable<mctree.Node["loc"]>;
+}
+export declare function isErrorWithLocation(e: Error): e is ErrorWithLocation;
+declare global {
+    type BuildConfig = {
+        workspace?: string;
+        jungleFiles?: string;
+        developerKeyPath?: string;
+        typeCheckLevel?: string;
+        compilerOptions?: string;
+        compilerWarnings?: boolean;
+        simulatorBuild?: boolean;
+        releaseBuild?: boolean;
+        testBuild?: boolean;
+        products?: string[];
+        buildDir?: string;
+        outputPath?: string;
+        program?: string;
+        skipOptimization?: boolean;
+        checkManifest?: boolean;
+        device?: string;
+        ignoredExcludeAnnotations?: string;
+        ignoredAnnotations?: string;
+        ignoredSourcePaths?: string;
+        returnCommand?: boolean;
+        _cache?: {
+            barrels?: Record<string, ResolvedJungle>;
+            barrelMap?: Record<string, Record<string, ResolvedJungle>>;
+        };
+    };
+    type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier | mctree.EnumDeclaration | mctree.TypedefDeclaration | mctree.VariableDeclarator;
+    type StateNodeDecls = {
+        [key: string]: StateNodeDecl[];
+    };
+    type ProgramStateNode = {
+        type: "Program";
+        node: null | undefined;
+        name: "$";
+        fullName: "$";
+        decls?: StateNodeDecls;
+        stack?: null | undefined;
+    };
+    type ModuleStateNode = {
+        type: "ModuleDeclaration";
+        name: string;
+        fullName: string;
+        node: mctree.ModuleDeclaration;
+        stack?: ProgramStateStack;
+        decls?: StateNodeDecls;
+    };
+    type ClassStateNode = {
+        type: "ClassDeclaration";
+        name: string;
+        fullName: string;
+        node: mctree.ClassDeclaration;
+        decls?: StateNodeDecls;
+        stack?: ProgramStateStack;
+        superClass: ClassStateNode[] | true;
+    };
+    type FunctionStateNode = {
+        type: "FunctionDeclaration";
+        name: string;
+        fullName: string;
+        node: mctree.FunctionDeclaration;
+        stack?: ProgramStateStack;
+        decls?: undefined;
+    };
+    type BlockStateNode = {
+        type: "BlockStatement";
+        name?: null | undefined;
+        fullName?: null | undefined;
+        node: mctree.BlockStatement;
+        decls?: StateNodeDecls;
+        stack?: null | undefined;
+    };
+    type StateNode = ProgramStateNode | FunctionStateNode | BlockStateNode | ClassStateNode | ModuleStateNode;
+    type ProgramStateStack = StateNode[];
+    export type ProgramState = {
+        allFunctions?: FunctionStateNode[];
+        allClasses?: ClassStateNode[];
+        stack?: ProgramStateStack;
+        shouldExclude?: (node: any) => any;
+        pre?: (node: mctree.Node, state: ProgramStateLive) => null | false | (keyof mctree.NodeAll)[];
+        post?: (node: mctree.Node, state: ProgramStateLive) => null | false | mctree.Node;
+        lookup?: (node: mctree.Node, name?: string | null, stack?: ProgramStateStack) => [string, StateNodeDecl[], ProgramStateStack] | [null, null, null];
+        traverse?: (node: mctree.Node) => void | null | false | mctree.Node;
+        exposed?: {
+            [key: string]: true;
+        };
+        calledFunctions?: {
+            [key: string]: unknown[];
+        };
+        localsStack?: {
+            node?: mctree.Node;
+            map?: {
+                [key: string]: true | string;
+            };
+            inners?: {
+                [key: string]: true;
+            };
+        }[];
+        index?: {
+            [key: string]: unknown[];
+        };
+        constants?: {
+            [key: string]: mctree.Literal;
+        };
+    };
+    type Finalized<T, Keys extends keyof T> = T & {
+        [key in Keys]-?: NonNullable<T[key]>;
+    };
+    export type ProgramStateLive = Finalized<ProgramState, "stack" | "lookup" | "traverse" | "index" | "constants">;
+    export type ProgramStateAnalysis = Finalized<ProgramStateLive, "allClasses" | "allFunctions">;
+    export type ProgramStateOptimizer = Finalized<ProgramStateAnalysis, "localsStack" | "exposed" | "calledFunctions">;
+    type ExcludeAnnotationsMap = {
+        [key: string]: boolean;
+    };
+    type FilesToOptimizeMap = {
+        [key: string]: {
+            output: string;
+            excludeAnnotations: ExcludeAnnotationsMap;
+            monkeyCSource?: string;
+            ast?: mctree.Program;
+            parserError?: Error;
+            hasTests?: boolean;
+        };
+    };
+    var lastModifiedSource: number;
+}
+/**
+ *
+ * @param {string | null} product
+ * @param {BuildConfig} options
+ * @returns
+ */
+export declare function buildOptimizedProject(product: string | null, options: BuildConfig): Promise<{
+    exe: string;
+    args: string[];
+    program: string;
+    product: string | null;
+    hasTests: boolean | undefined;
+}>;
+export declare function generateOptimizedProject(options: BuildConfig): Promise<{
+    jungleFiles: string | undefined;
+    program: string;
+    xml?: undefined;
+    hasTests?: undefined;
+} | {
+    jungleFiles: string;
+    xml: import("./manifest").ManifestXML;
+    program: string;
+    hasTests: boolean;
+}>;
+export declare type PreAnalysis = {
+    fnMap: FilesToOptimizeMap;
+    paths: string[];
+};
+declare type RequiredNonNull<T> = {
+    [K1 in keyof T]-?: {
+        [K2 in keyof T[K1]]-?: NonNullable<T[K1][K2]>;
+    };
+};
+export declare type Analysis = {
+    fnMap: RequiredNonNull<FilesToOptimizeMap>;
+    paths: string[];
+    state: ProgramState;
+};
+export declare function getProjectAnalysis(targets: Target[], analysis: PreAnalysis | null, options: BuildConfig): Promise<Analysis | PreAnalysis>;
+/**
+ *
+ * @param {BuildConfig} options
+ * @returns
+ */
+export declare function generateApiMirTests(options: BuildConfig): Promise<void>;

package/build/src/sdk-util.d.ts

@@ -0,0 +1,15 @@
+export declare const isWin: boolean;
+export declare const appSupport: string;
+export declare const connectiq: string;
+export declare function getSdkPath(): Promise<string>;
+export declare function getDeviceInfo(): Promise<{
+    [key: string]: {
+        appTypes: {
+            memoryLimit: number;
+            type: string;
+        }[];
+        deviceFamily: string;
+        displayName: string;
+    };
+}>;
+export declare function getLanguages(): Promise<any>;

package/build/src/util.d.ts

@@ -0,0 +1,13 @@
+import * as glob from "glob";
+export declare function globa(pattern: string, options?: glob.IOptions): Promise<Array<string>>;
+export declare function last_modified(inputs: string[]): Promise<number>;
+export declare function first_modified(inputs: string[]): Promise<number>;
+export declare function pushUnique<T>(arr: T[], value: T): void;
+declare type LineHandler = (line: string) => void;
+export declare function spawnByLine(command: string, args: string[], lineHandlers: LineHandler | LineHandler[], options?: {
+    [key: string]: unknown;
+}): Promise<void>;
+export declare function readByLine(file: string, lineHandler: LineHandler): Promise<unknown>;
+export declare function promiseAll<T>(promiseFn: (i: number) => Promise<T>, parallelism: number): Promise<T[]>;
+export declare function copyRecursiveAsNeeded(source: string, target: string, filter?: (src: string, tgt: string) => boolean): Promise<void>;
+export {};

package/build/util.cjs

@@ -3952,6 +3952,18 @@ module.exports = require("util");
 /******/ 		};
 /******/ 	})();
 /******/ 	
+/******/ 	/* webpack/runtime/global */
+/******/ 	(() => {
+/******/ 		__webpack_require__.g = (function() {
+/******/ 			if (typeof globalThis === 'object') return globalThis;
+/******/ 			try {
+/******/ 				return this || new Function('return this')();
+/******/ 			} catch (e) {
+/******/ 				if (typeof window === 'object') return window;
+/******/ 			}
+/******/ 		})();
+/******/ 	})();
+/******/ 	
 /******/ 	/* webpack/runtime/hasOwnProperty shorthand */
 /******/ 	(() => {
 /******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
@@ -4000,8 +4012,7 @@ var glob = __webpack_require__(2884);
 var external_path_ = __webpack_require__(1423);
 ;// CONCATENATED MODULE: external "readline"
 const external_readline_namespaceObject = require("readline");
-;// CONCATENATED MODULE: ./src/util.js
-
+;// CONCATENATED MODULE: ./src/util.ts
 
 
 
@@ -4010,143 +4021,132 @@ const external_readline_namespaceObject = require("readline");
 
 // Write it this way so that webpack.DefinePlugin doesn't
 // recognize global.lastModifiedSource.
-global["lastModifiedSource" + ""] = 0;
-
+// @ts-ignore
+__webpack_require__.g["lastModifiedSource" + ""] = 0;
 function globa(pattern, options) {
-  return new Promise((resolve, reject) => {
-    glob.glob(pattern, options, (er, files) => {
-      if (er) {
-        reject(files);
-      } else {
-        resolve(files);
-      }
+    return new Promise((resolve, reject) => {
+        glob.glob(pattern, options || {}, (er, files) => {
+            if (er) {
+                reject(files);
+            }
+            else {
+                resolve(files);
+            }
+        });
     });
-  });
 }
-
 async function modified_times(inputs, missing) {
-  return Promise.all(
-    inputs.map(async (path) => {
-      try {
-        const stat = await promises_namespaceObject.stat(path);
-        return stat.mtimeMs;
-      } catch (e) {
-        return missing;
-      }
-    })
-  );
+    return Promise.all(inputs.map(async (path) => {
+        try {
+            const stat = await promises_namespaceObject.stat(path);
+            return stat.mtimeMs;
+        }
+        catch (e) {
+            return missing;
+        }
+    }));
 }
-
 async function last_modified(inputs) {
-  return Math.max(...(await modified_times(inputs, Infinity)));
+    return Math.max(...(await modified_times(inputs, Infinity)));
 }
-
 async function first_modified(inputs) {
-  return Math.min(...(await modified_times(inputs, 0)));
+    return Math.min(...(await modified_times(inputs, 0)));
 }
-
 function pushUnique(arr, value) {
-  if (arr.find((v) => v === value) != null) return;
-  arr.push(value);
+    if (arr.find((v) => v === value) != null)
+        return;
+    arr.push(value);
 }
-
 // return a promise that will process the output of command
 // line-by-line via lineHandlers.
 function spawnByLine(command, args, lineHandlers, options) {
-  const [lineHandler, errHandler] = Array.isArray(lineHandlers)
-    ? lineHandlers
-    : [lineHandlers, (data) => console.error(data.toString())];
-  return new Promise((resolve, reject) => {
-    const proc = external_child_process_namespaceObject.spawn(command, args, {
-      ...(options || {}),
-      shell: false,
-    });
-    const rl = external_readline_namespaceObject.createInterface({
-      input: proc.stdout,
-    });
-    const rle = external_readline_namespaceObject.createInterface({
-      input: proc.stderr,
-    });
-    proc.on("error", reject);
-    rle.on("line", errHandler);
-    rl.on("line", lineHandler);
-    proc.on("close", (code) => {
-      if (code == 0) resolve();
-      reject(code);
+    const [lineHandler, errHandler] = Array.isArray(lineHandlers)
+        ? lineHandlers
+        : [lineHandlers, (line) => console.error(line)];
+    return new Promise((resolve, reject) => {
+        const proc = external_child_process_namespaceObject.spawn(command, args, {
+            ...(options || {}),
+            shell: false,
+        });
+        const rl = external_readline_namespaceObject.createInterface({
+            input: proc.stdout,
+        });
+        const rle = external_readline_namespaceObject.createInterface({
+            input: proc.stderr,
+        });
+        proc.on("error", reject);
+        rle.on("line", errHandler);
+        rl.on("line", lineHandler);
+        proc.on("close", (code) => {
+            if (code == 0)
+                resolve();
+            reject(code);
+        });
     });
-  });
 }
-
 // return a promise that will process file
 // line-by-line via lineHandler.
 function readByLine(file, lineHandler) {
-  return promises_namespaceObject.open(file, "r").then(
-    (fh) =>
-      new Promise((resolve, _reject) => {
+    return promises_namespaceObject.open(file, "r").then((fh) => new Promise((resolve, _reject) => {
         const stream = fh.createReadStream();
         const rl = external_readline_namespaceObject.createInterface({
-          input: stream,
+            input: stream,
         });
         rl.on("line", lineHandler);
         stream.on("close", resolve);
-      })
-  );
+    }));
 }
-
 async function promiseAll(promiseFn, parallelism) {
-  parallelism = parallelism || 4;
-  const serializer = [];
-  const results = [];
-  let done = false;
-  let i = 0;
-  const next = () => {
-    const index = i++;
-    if (done) return;
-    const promise = promiseFn(index);
-    if (!promise) {
-      done = true;
-      return;
+    parallelism = parallelism || 4;
+    const serializer = [];
+    const results = [];
+    let done = false;
+    let i = 0;
+    const next = () => {
+        const index = i++;
+        if (done)
+            return null;
+        const promise = promiseFn(index);
+        if (!promise) {
+            done = true;
+            return null;
+        }
+        return promise
+            .then((r) => {
+            results[index] = r;
+        })
+            .then(next);
+    };
+    while (i < parallelism) {
+        serializer.push(next());
     }
-    return promise
-      .then((r) => {
-        results[index] = r;
-      })
-      .then(next);
-  };
-  while (i < parallelism) {
-    serializer.push(next());
-  }
-  return Promise.all(serializer).then(() => results);
+    return Promise.all(serializer).then(() => results);
 }
-
 async function copyRecursiveAsNeeded(source, target, filter) {
-  const fstat = promises_namespaceObject.stat;
-  const sstat = await fstat(source);
-  if (sstat.isDirectory()) {
-    const stat = await fstat(target).catch(() => null);
-
-    if (!stat || !stat.isDirectory()) {
-      stat && (await promises_namespaceObject.rm(target, { force: true }));
-      await promises_namespaceObject.mkdir(target, { recursive: true });
-    }
-
-    const files = await promises_namespaceObject.readdir(source);
-    return Promise.all(
-      files.map((file) => {
-        var src = external_path_.join(source, file);
-        var tgt = external_path_.join(target, file);
-        return copyRecursiveAsNeeded(src, tgt, filter);
-      })
-    );
-  } else {
-    if (filter && !filter(source, target)) {
-      return;
+    const fstat = promises_namespaceObject.stat;
+    const sstat = await fstat(source);
+    if (sstat.isDirectory()) {
+        const stat = await fstat(target).catch(() => null);
+        if (!stat || !stat.isDirectory()) {
+            stat && (await promises_namespaceObject.rm(target, { force: true }));
+            await promises_namespaceObject.mkdir(target, { recursive: true });
+        }
+        const files = await promises_namespaceObject.readdir(source);
+        return Promise.all(files.map((file) => {
+            var src = external_path_.join(source, file);
+            var tgt = external_path_.join(target, file);
+            return copyRecursiveAsNeeded(src, tgt, filter);
+        })).then(() => { });
     }
-    const tstat = await fstat(target).catch(() => null);
-    if (!tstat || tstat.mtimeMs < sstat.mtimeMs) {
-      return promises_namespaceObject.copyFile(source, target, external_fs_.constants.COPYFILE_FICLONE);
+    else {
+        if (filter && !filter(source, target)) {
+            return;
+        }
+        const tstat = await fstat(target).catch(() => null);
+        if (!tstat || tstat.mtimeMs < sstat.mtimeMs) {
+            return promises_namespaceObject.copyFile(source, target, external_fs_.constants.COPYFILE_FICLONE);
+        }
     }
-  }
 }
 
 })();

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "module",
-  "version": "1.0.10",
+  "version": "1.0.13",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
+  "types": "build/src/optimizer.d.ts",
   "exports": {
     ".": "./build/optimizer.cjs",
     "./*.js": "./build/*.cjs"
@@ -20,20 +21,26 @@
     "build/optimizer.cjs",
     "build/util.cjs",
     "build/sdk-util.cjs",
-    "build/api.cjs"
+    "build/api.cjs",
+    "build/src/*.d.ts"
   ],
   "author": "markw65",
   "license": "MIT",
   "dependencies": {
-    "@markw65/prettier-plugin-monkeyc": "^1.0.16"
+    "@markw65/prettier-plugin-monkeyc": "^1.0.20"
   },
   "devDependencies": {
+    "@types/glob": "^7.2.0",
+    "@types/prettier": "^2.6.1",
+    "@types/xml2js": "^0.4.11",
     "eslint": "^8.12.0",
     "extract-zip": "^2.0.1",
     "glob": "^7.2.0",
     "peggy": "^1.2.0",
     "prettier": "^2.6.2",
     "prettier-plugin-pegjs": "^0.5.0",
+    "ts-loader": "^9.3.0",
+    "typescript": "^4.6.4",
     "webpack": "^5.72.0",
     "webpack-cli": "^4.9.2",
     "xml2js": "^0.4.23"