@markw65/monkeyc-optimizer 1.0.10 → 1.0.13

package/build/sdk-util.cjs

@@ -7187,53 +7187,52 @@ const external_path_namespaceObject = require("path");
 var xml2js = __webpack_require__(5055);
 ;// CONCATENATED MODULE: external "./util.cjs"
 const external_util_cjs_namespaceObject = require("./util.cjs");
-;// CONCATENATED MODULE: ./src/sdk-util.js
-
+;// CONCATENATED MODULE: ./src/sdk-util.ts
 
 
 
 
 const isWin = process.platform == "win32";
-
 const appSupport = isWin
-  ? `${process.env.APPDATA}`.replace(/\\/g, "/")
-  : `${process.env.HOME}/Library/Application Support`;
-
-const connectiq = `${appSupport}/Garmin/ConnectIQ`;
-
+    ? `${process.env.APPDATA}`.replace(/\\/g, "/")
+    : process.platform == "linux"
+        ? `${process.env.HOME}/.config`
+        : `${process.env.HOME}/Library/Application Support`;
+const connectiq = process.platform == "linux"
+    ? `${process.env.HOME}/.Garmin/ConnectIQ`
+    : `${appSupport}/Garmin/ConnectIQ`;
 function getSdkPath() {
-  return promises_namespaceObject.readFile(connectiq + "/current-sdk.cfg")
-    .then((contents) => contents.toString().replace(/^\s*(.*?)\s*$/s, "$1"));
+    return promises_namespaceObject.readFile(connectiq + "/current-sdk.cfg")
+        .then((contents) => contents.toString().replace(/^\s*(.*?)\s*$/s, "$1"))
+        .catch(() => {
+        throw new Error(`No sdk found at '${connectiq}'. Check your sdk is correctly installed`);
+    });
 }
-
 async function getDeviceInfo() {
-  const files = await (0,external_util_cjs_namespaceObject.globa)(`${connectiq}/Devices/*/compiler.json`);
-  return Promise.all(
-    files.map((file) => {
-      return promises_namespaceObject.readFile(file).then((data) => {
-        const { deviceId, appTypes, deviceFamily } = JSON.parse(
-          data.toString()
-        );
-        return [deviceId, { appTypes, deviceFamily }];
-      });
-    })
-  ).then((info) => {
-    return Object.fromEntries(info);
-  });
+    const files = await (0,external_util_cjs_namespaceObject.globa)(`${connectiq}/Devices/*/compiler.json`);
+    if (!files.length) {
+        throw new Error(`No devices found at '${connectiq}/Devices'. Check your sdk is correctly installed`);
+    }
+    return Promise.all(files.map((file) => {
+        return promises_namespaceObject.readFile(file).then((data) => {
+            const { deviceId, appTypes, deviceFamily, displayName } = JSON.parse(data.toString());
+            return [deviceId, { appTypes, deviceFamily, displayName }];
+        });
+    })).then((info) => {
+        return Object.fromEntries(info);
+    });
 }
-
 async function getProjectInfo() {
-  const sdk = await getSdkPath();
-  const data = await promises_namespaceObject.readFile(external_path_namespaceObject.join(sdk, "bin", "projectInfo.xml"));
-  return (0,xml2js.parseStringPromise)(data.toString(), { trim: true });
+    const sdk = await getSdkPath();
+    const data = await promises_namespaceObject.readFile(external_path_namespaceObject.join(sdk, "bin", "projectInfo.xml"));
+    return (0,xml2js.parseStringPromise)(data.toString(), { trim: true });
 }
-
 async function getLanguages() {
-  const projectInfo = await getProjectInfo();
-  return projectInfo["monkeybrains"]["languages"][0]["language"].map((p) => ({
-    id: p.$.id,
-    name: p.$.name,
-  }));
+    const projectInfo = await getProjectInfo();
+    return projectInfo["monkeybrains"]["languages"][0]["language"].map((p) => ({
+        id: p.$.id,
+        name: p.$.name,
+    }));
 }
 
 })();

package/build/src/api.d.ts

@@ -0,0 +1,9 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+export declare function getApiMapping(state?: ProgramState): Promise<ProgramStateNode | null>;
+export declare function hasProperty<T extends null extends T ? unknown : undefined extends T ? unknown : never>(obj: T, prop: string): obj is NonNullable<T>;
+export declare function hasProperty<T>(obj: T, prop: string): boolean;
+export declare function isStateNode(node: StateNodeDecl): node is StateNode;
+export declare function variableDeclarationName(node: mctree.TypedIdentifier): string;
+export declare function collectNamespaces(ast: mctree.Program, stateIn?: ProgramState): ProgramStateNode;
+export declare function traverseAst(node: mctree.Node, pre?: null | ((node: mctree.Node) => void | null | false | (keyof mctree.NodeAll)[]), post?: (node: mctree.Node) => void | null | false | mctree.Node): false | void | null | mctree.Node;
+export declare function formatAst(node: mctree.Node, monkeyCSource?: string | null): string;

package/build/src/build.d.ts

@@ -0,0 +1,6 @@
+export declare function build_project(product: string | null, options: BuildConfig, lineCallback?: (line: string) => void): Promise<{
+    exe: string;
+    args: string[];
+    program: string;
+    product: string | null;
+}>;

package/build/src/estree-types.d.ts

@@ -0,0 +1,324 @@
+declare type InclusiveUnionKeys<U> = U extends unknown ? keyof U : never;
+declare type InclusiveUnion<U> = {
+    [K in InclusiveUnionKeys<U>]: U extends any ? K extends keyof U ? U[K] : never : never;
+};
+declare type SubfieldsOfType<T, U> = {
+    [K in keyof T as T[K] extends U ? K : never]: T[K];
+};
+export declare type NodeAll = InclusiveUnion<Node>;
+export declare type NodeSubFields = SubfieldsOfType<NodeAll, Node>;
+export declare type NodeSubArrays = SubfieldsOfType<NodeAll, Node[]>;
+interface BaseNode {
+    type: string;
+    loc?: SourceLocation | null | undefined;
+    start?: number;
+    end?: number;
+    range?: [number, number] | undefined;
+}
+export declare type Node = Identifier | Literal | Program | SwitchCase | CatchClause | VariableDeclarator | EnumStringBody | EnumStringMember | Statement | Expression | Property | Declaration | ImportStatement | AsTypeSpec | TypeSpecList | ClassElement | ClassBody | Comment;
+export interface Comment extends BaseNode {
+    type: "Line" | "Block";
+    value: string;
+}
+interface SourceLocation {
+    source?: string | null | undefined;
+    start: Position;
+    end: Position;
+}
+export interface Position {
+    /** >= 1 */
+    line: number;
+    /** >= 0 */
+    column: number;
+}
+export interface Program extends BaseNode {
+    type: "Program";
+    body: Array<Declaration | ImportStatement>;
+    comments?: Array<Comment> | undefined;
+}
+export interface ModuleDeclaration extends BaseDeclaration {
+    type: "ModuleDeclaration";
+    body: Array<Declaration | ImportStatement>;
+    id: Identifier;
+}
+interface BaseFunction extends BaseNode {
+    params: Array<Identifier | AsExpression>;
+    body: BlockStatement;
+}
+export declare type Statement = ExpressionStatement | BlockStatement | ReturnStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | Declaration;
+interface BaseStatement extends BaseNode {
+}
+export interface BlockStatement extends BaseStatement {
+    type: "BlockStatement";
+    body: Array<Statement>;
+    innerComments?: Array<Comment> | undefined;
+}
+export interface ExpressionStatement extends BaseStatement {
+    type: "ExpressionStatement";
+    expression: Expression;
+}
+export interface IfStatement extends BaseStatement {
+    type: "IfStatement";
+    test: Expression;
+    consequent: Statement;
+    alternate?: Statement | null | undefined;
+}
+export interface BreakStatement extends BaseStatement {
+    type: "BreakStatement";
+}
+export interface ContinueStatement extends BaseStatement {
+    type: "ContinueStatement";
+}
+export interface SwitchStatement extends BaseStatement {
+    type: "SwitchStatement";
+    discriminant: Expression;
+    cases: Array<SwitchCase>;
+}
+export interface ReturnStatement extends BaseStatement {
+    type: "ReturnStatement";
+    argument?: Expression | null | undefined;
+}
+export interface ThrowStatement extends BaseStatement {
+    type: "ThrowStatement";
+    argument: Expression;
+}
+export interface TryStatement extends BaseStatement {
+    type: "TryStatement";
+    block: BlockStatement;
+    handler?: CatchClause | CatchClauses | null | undefined;
+    finalizer?: BlockStatement | null | undefined;
+}
+export interface WhileStatement extends BaseStatement {
+    type: "WhileStatement";
+    test: Expression;
+    body: Statement;
+}
+export interface DoWhileStatement extends BaseStatement {
+    type: "DoWhileStatement";
+    body: Statement;
+    test: Expression;
+}
+export interface ForStatement extends BaseStatement {
+    type: "ForStatement";
+    init?: VariableDeclaration | Expression | null | undefined;
+    test?: Expression | null | undefined;
+    update?: Expression | null | undefined;
+    body: Statement;
+}
+export declare type Declaration = ClassDeclaration | EnumDeclaration | FunctionDeclaration | ModuleDeclaration | TypedefDeclaration | VariableDeclaration;
+interface BaseDeclaration extends BaseStatement {
+    attrs?: AttributeList;
+}
+export interface FunctionDeclaration extends BaseFunction, BaseDeclaration {
+    type: "FunctionDeclaration";
+    id: Identifier;
+    body: BlockStatement;
+    optimizable?: boolean;
+    hasOverride?: boolean;
+}
+export interface VariableDeclaration extends BaseDeclaration {
+    type: "VariableDeclaration";
+    declarations: Array<VariableDeclarator>;
+    kind: "var" | "const";
+}
+export interface VariableDeclarator extends BaseNode {
+    type: "VariableDeclarator";
+    id: Identifier | AsExpression;
+    init?: Expression | null | undefined;
+    kind: "var" | "const";
+}
+declare type Expression = ThisExpression | ArrayExpression | ObjectExpression | Literal | UnaryExpression | UpdateExpression | BinaryExpression | AsExpression | AssignmentExpression | LogicalExpression | MemberExpression | ConditionalExpression | CallExpression | NewExpression | SequenceExpression | Identifier;
+export interface BaseExpression extends BaseNode {
+    enumType?: string | Node;
+}
+export interface ThisExpression extends BaseExpression {
+    type: "ThisExpression";
+    text: string;
+}
+export interface ArrayExpression extends BaseExpression {
+    type: "ArrayExpression";
+    elements: Array<Expression>;
+}
+export interface ObjectExpression extends BaseExpression {
+    type: "ObjectExpression";
+    properties: Array<Property>;
+}
+export interface Property extends BaseNode {
+    type: "Property";
+    key: Expression;
+    value: Expression;
+    kind: "init";
+}
+export interface SequenceExpression extends BaseExpression {
+    type: "SequenceExpression";
+    expressions: Array<Expression>;
+}
+interface BaseUnaryExpression extends BaseExpression {
+    type: "UnaryExpression";
+    prefix: true;
+}
+interface TrueUnaryExpression extends BaseUnaryExpression {
+    operator: UnaryOperator;
+    argument: Expression;
+}
+interface SymbolExpression extends BaseUnaryExpression {
+    operator: ":";
+    argument: Identifier;
+}
+export declare type UnaryExpression = TrueUnaryExpression | SymbolExpression;
+export interface BinaryExpression extends BaseExpression {
+    type: "BinaryExpression";
+    operator: BinaryOperator;
+    left: Expression;
+    right: Expression;
+}
+export interface AsExpression extends BaseExpression {
+    type: "BinaryExpression";
+    operator: "as";
+    left: Expression;
+    right: TypeSpecList;
+}
+export interface AssignmentExpression extends BaseExpression {
+    type: "AssignmentExpression";
+    operator: AssignmentOperator;
+    left: Identifier | MemberExpression;
+    right: Expression;
+}
+export interface UpdateExpression extends BaseExpression {
+    type: "UpdateExpression";
+    operator: UpdateOperator;
+    argument: Expression;
+    prefix: boolean;
+}
+export interface LogicalExpression extends BaseExpression {
+    type: "LogicalExpression";
+    operator: LogicalOperator;
+    left: Expression;
+    right: Expression;
+}
+export interface ConditionalExpression extends BaseExpression {
+    type: "ConditionalExpression";
+    test: Expression;
+    alternate: Expression;
+    consequent: Expression;
+}
+interface BaseCallExpression extends BaseExpression {
+    callee: Expression;
+    arguments: Array<Expression>;
+}
+export declare type CallExpression = SimpleCallExpression | NewExpression;
+export interface SimpleCallExpression extends BaseCallExpression {
+    type: "CallExpression";
+}
+export interface NewExpression extends BaseCallExpression {
+    type: "NewExpression";
+}
+export interface MemberExpression extends BaseExpression {
+    type: "MemberExpression";
+    object: Expression;
+    property: Expression;
+    computed: boolean;
+}
+export interface SwitchCase extends BaseNode {
+    type: "SwitchCase";
+    test?: Expression | null | undefined;
+    consequent: Array<Statement>;
+}
+export interface CatchClause extends BaseNode {
+    type: "CatchClause";
+    param: Identifier | null;
+    body: BlockStatement;
+}
+export interface CatchClauses extends BaseNode {
+    type: "CatchClauses";
+    catches: CatchClause[];
+}
+export interface Identifier extends BaseNode, BaseExpression {
+    type: "Identifier";
+    name: string;
+}
+export interface Literal extends BaseNode, BaseExpression {
+    type: "Literal";
+    value: string | boolean | number | null;
+    raw?: string | undefined;
+}
+export declare type UnaryOperator = "-" | "+" | "!" | "~" | " as";
+export declare type BinaryOperator = "==" | "!=" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "has" | "instanceof";
+export declare type LogicalOperator = "||" | "&&";
+export declare type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | "|=" | "^=" | "&=";
+export declare type UpdateOperator = "++" | "--";
+export interface ClassDeclaration extends BaseDeclaration {
+    type: "ClassDeclaration";
+    id: Identifier;
+    superClass?: Expression | null | undefined;
+    body: ClassBody;
+}
+export interface ClassBody extends BaseStatement {
+    type: "ClassBody";
+    body: Array<ClassElement>;
+}
+export interface ClassElement extends BaseStatement {
+    type: "ClassElement";
+    item: Omit<Declaration, "ModuleDeclaration">;
+}
+export interface EnumDeclaration extends BaseDeclaration {
+    type: "EnumDeclaration";
+    id?: Identifier | null;
+    body: EnumStringBody;
+}
+export interface EnumStringBody extends BaseNode {
+    type: "EnumStringBody";
+    members: Array<EnumStringMember | Identifier>;
+    enumType?: string | Node;
+}
+export interface EnumStringMember extends BaseNode {
+    type: "EnumStringMember";
+    id: Identifier;
+    init: Expression;
+    enumType?: string | Node;
+}
+export interface TypedefDeclaration extends BaseDeclaration {
+    type: "TypedefDeclaration";
+    id: Identifier;
+    ts: AsTypeSpec;
+}
+export interface AsTypeSpec extends Omit<UnaryExpression, "operator" | "argument"> {
+    operator: " as";
+    argument: TypeSpecList;
+}
+export interface TypeSpecList extends BaseNode {
+    type: "TypeSpecList";
+    ts: Array<TypeSpecPart>;
+}
+export interface TypeSpecPart extends BaseNode {
+    type: "TypeSpecPart";
+    name: Identifier | MemberExpression;
+    body?: BlockStatement;
+    callspec?: MethodDefinition;
+    generics?: Array<TypeSpecList>;
+}
+export interface MethodDefinition extends BaseNode {
+    type: "MethodDefinition";
+    kind: "method";
+    key: "";
+    params: Array<Identifier | AsExpression>;
+    returnType: AsTypeSpec;
+}
+export declare type AccessSpecifier = "static" | "private" | "protected" | "hidden" | "public";
+export interface AttributeList extends BaseNode {
+    type: "AttributeList";
+    attrs?: Attribute[];
+    access?: AccessSpecifier[];
+}
+declare type Attribute = SymbolExpression | CallExpression;
+export declare type ImportStatement = ImportModule | Using;
+export interface ImportModule extends BaseNode {
+    type: "ImportModule";
+    id: MemberExpression;
+}
+export interface Using extends BaseNode {
+    type: "Using";
+    id: MemberExpression;
+    as: Identifier;
+}
+export {};

package/build/src/jungles.d.ts

@@ -0,0 +1,51 @@
+import { ManifestXML } from "./manifest";
+export declare type Target = {
+    product: string;
+    qualifier: JungleQualifier;
+    shape?: string;
+    group?: {
+        optimizerConfig: JungleQualifier;
+        dir?: string;
+        key: string;
+    };
+};
+declare type LangResourcePaths = {
+    [key: string]: string[];
+};
+declare type BarrelAnnotations = {
+    [key: string]: string[];
+};
+declare type BarrelMap = {
+    [key: string]: ResolvedBarrel;
+};
+declare type OptBarrelMap = Record<string, {
+    rawBarrelDir: string;
+    manifest: string;
+    jungleFiles: string[];
+    optBarrelDir: string;
+}>;
+export declare type JungleQualifier = {
+    sourcePath?: string[];
+    sourceExcludes?: string[];
+    excludeAnnotations?: string[];
+    resourcePath?: string[];
+    lang?: LangResourcePaths;
+    barrelPath?: (string | string[])[];
+    annotations?: BarrelAnnotations;
+    barrelMap?: BarrelMap;
+    optBarrels?: OptBarrelMap;
+};
+declare type JungleInfoBase = {
+    jungles: string[];
+    manifest: string;
+    xml: ManifestXML;
+    annotations?: string[];
+};
+export declare type ResolvedJungle = JungleInfoBase & {
+    targets: Target[];
+};
+export declare type ResolvedBarrel = JungleInfoBase & {
+    qualifier: JungleQualifier;
+};
+export declare function get_jungle(jungles: string, options: BuildConfig): Promise<ResolvedJungle>;
+export {};

package/build/src/launch.d.ts

@@ -0,0 +1,2 @@
+export declare function launchSimulator(): Promise<void>;
+export declare function simulateProgram(prg: string, device: string, test?: boolean): Promise<void>;

package/build/src/manifest.d.ts

@@ -0,0 +1,71 @@
+declare type iqApplication = {
+    $: {
+        id: string;
+        entry: string;
+        launcherIcon: string;
+        minSdkVersion: string;
+        name: string;
+        type: string;
+        version: string;
+    };
+    "iq:products"?: Array<{
+        "iq:product"?: Array<{
+            $: {
+                id: string;
+            };
+        }>;
+    }>;
+    "iq:barrels"?: Array<{
+        "iq:depends"?: Array<{
+            $: {
+                name: string;
+                version: string;
+            };
+        }>;
+    }>;
+    "iq:permissions"?: Array<{
+        "iq:uses-permission"?: Array<{
+            $: {
+                id: string;
+            };
+        }>;
+    }>;
+    "iq:languages"?: Array<{
+        "iq:language"?: Array<string>;
+    }>;
+};
+declare type iqBarrel = {
+    $: {
+        id: string;
+        module: string;
+        version: string;
+    };
+    "iq:products"?: Array<{
+        "iq:product"?: Array<{
+            $: {
+                id: string;
+            };
+        }>;
+    }>;
+    "iq:annotations"?: Array<{
+        "iq:annotation"?: Array<string>;
+    }>;
+};
+export declare type ManifestXML = {
+    "iq:manifest": {
+        $: {
+            "xmlns:iq": string;
+        };
+        "iq:application"?: Array<iqApplication>;
+        "iq:barrel"?: Array<iqBarrel>;
+    };
+};
+export declare function readManifest(manifest: string): Promise<ManifestXML>;
+export declare function writeManifest(filename: string, xml: ManifestXML): Promise<void>;
+export declare function manifestProducts(manifest: ManifestXML): string[];
+export declare function manifestBarrels(manifest: ManifestXML): string[];
+export declare function manifestDropBarrels(manifest: ManifestXML): void;
+export declare function manifestBarrelName(manifestName: string, manifest: ManifestXML): string;
+export declare function manifestAnnotations(manifest: ManifestXML): string[] | undefined;
+export declare function checkManifest(manifest: ManifestXML, products: string[]): Promise<boolean>;
+export {};

package/build/src/mc-rewrite.d.ts

@@ -0,0 +1,7 @@
+import { mctree } from "@markw65/prettier-plugin-monkeyc";
+export declare function getFileSources(fnMap: FilesToOptimizeMap): Promise<void>;
+export declare function getFileASTs(fnMap: FilesToOptimizeMap): Promise<boolean>;
+export declare function analyze(fnMap: FilesToOptimizeMap): Promise<ProgramStateAnalysis>;
+export declare function getLiteralFromDecls(decls: StateNodeDecl[]): null;
+export declare function getLiteralNode(node: mctree.Node | null | undefined): null | mctree.Literal | mctree.AsExpression;
+export declare function optimizeMonkeyC(fnMap: FilesToOptimizeMap): Promise<void>;

package/build/src/negative-fixups.d.ts

@@ -0,0 +1 @@
+export declare const negativeFixups: string[];