@markw65/monkeyc-optimizer 1.0.38 → 1.0.39

package/build/src/api.d.ts

@@ -1,9 +1,10 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { hasProperty, traverseAst } from "./ast";
-import { LookupDefinition, ProgramState, ProgramStateLive, ProgramStateNode, StateNode, StateNodeDecl, ProgramStateStack, FunctionInfo, FunctionStateNode } from "./optimizer-types";
-export { visitReferences } from "./visitor";
+import { JungleResourceMap } from "./jungles";
+import { FunctionInfo, FunctionStateNode, LookupDefinition, ProgramState, ProgramStateLive, ProgramStateNode, ProgramStateStack, StateNode, StateNodeDecl } from "./optimizer-types";
+export { visitorNode, visitReferences } from "./visitor";
 export { traverseAst, hasProperty };
-export declare function getApiMapping(state?: ProgramState, barrelList?: string[]): Promise<ProgramStateNode | null>;
+export declare function getApiMapping(state?: ProgramState, resourcesMap?: Record<string, JungleResourceMap>): Promise<ProgramStateNode | null>;
 export declare function isStateNode(node: StateNodeDecl): node is StateNode;
 export declare function variableDeclarationName(node: mctree.TypedIdentifier | mctree.InstanceofIdentifier): string;
 export declare function sameLookupResult(a: LookupDefinition[], b: LookupDefinition[]): boolean;

package/build/src/jungles.d.ts

@@ -1,5 +1,6 @@
 import { ManifestXML } from "./manifest";
 import { BuildConfig } from "./optimizer-types.js";
+import { xmlUtil } from "./sdk-util";
 export declare type Target = {
     product: string;
     qualifier: JungleQualifier;
@@ -35,13 +36,16 @@ export declare type JungleQualifier = {
     annotations?: BarrelAnnotations;
     barrelMap?: BarrelMap;
     optBarrels?: OptBarrelMap;
+    resourceMap?: JungleResourceMap;
 };
 declare type JungleInfoBase = {
     jungles: string[];
     manifest: string;
     xml: ManifestXML;
     annotations?: string[];
+    resources: JungleResourceMap;
 };
+export declare type JungleResourceMap = Record<string, xmlUtil.Document | Error>;
 export declare type ResolvedJungle = JungleInfoBase & {
     targets: Target[];
 };

package/build/src/launch.d.ts

@@ -1,5 +1,5 @@
 import { LineHandler } from "./util";
-export declare function launchSimulator(): Promise<void>;
+export declare function launchSimulator(force?: boolean): Promise<void>;
 export declare function checkIfSimulatorRunning(): Promise<boolean>;
 export declare function checkIfSimulatorRunningOn(port: number): Promise<boolean>;
 export declare function simulateProgram(prg: string, device: string, test?: boolean, logger?: LineHandler | LineHandler[]): Promise<void>;

package/build/src/manifest.d.ts

@@ -1,65 +1,5 @@
-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>;
-    };
-};
+import { xmlUtil } from "./sdk-util";
+export declare type ManifestXML = xmlUtil.Document;
 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[];
@@ -68,4 +8,3 @@ 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

@@ -1,11 +1,13 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
+import { JungleResourceMap } from "./jungles";
 import { BuildConfig, FilesToOptimizeMap, LookupDefinition, ProgramStateAnalysis } from "./optimizer-types";
 export declare function getFileSources(fnMap: FilesToOptimizeMap): Promise<void>;
 export declare function getFileASTs(fnMap: FilesToOptimizeMap): Promise<boolean>;
-export declare function analyze(fnMap: FilesToOptimizeMap, barrelList?: string[], config?: BuildConfig): Promise<ProgramStateAnalysis>;
+export declare function analyze(fnMap: FilesToOptimizeMap, resourcesMap?: Record<string, JungleResourceMap>, config?: BuildConfig): Promise<ProgramStateAnalysis>;
+export declare function reportMissingSymbols(state: ProgramStateAnalysis, config?: BuildConfig): void;
 export declare function getLiteralFromDecls(lookupDefns: LookupDefinition[]): mctree.Literal | mctree.AsExpression | null;
 export declare function getLiteralNode(node: mctree.Node | null | undefined): null | mctree.Literal | mctree.AsExpression;
-export declare function optimizeMonkeyC(fnMap: FilesToOptimizeMap, barrelList?: string[], config?: BuildConfig): Promise<Record<string, {
+export declare function optimizeMonkeyC(fnMap: FilesToOptimizeMap, resourcesMap?: Record<string, JungleResourceMap>, config?: BuildConfig): Promise<Record<string, {
     type: import("./optimizer-types").DiagnosticType;
     loc: {
         start: mctree.Position;

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

@@ -1,5 +1,4 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
-import { ResolvedJungle } from "./jungles";
 export declare type DiagnosticType = "ERROR" | "WARNING" | "INFO";
 export declare type BuildConfig = {
     workspace?: string;
@@ -27,10 +26,6 @@ export declare type BuildConfig = {
     sizeBasedPRE?: boolean | string;
     prettier?: Record<string, unknown>;
     extensionVersion?: string;
-    _cache?: {
-        barrels?: Record<string, ResolvedJungle>;
-        barrelMap?: Record<string, Record<string, ResolvedJungle>>;
-    };
 };
 export declare type StateNodeDecl = StateNode | mctree.EnumStringMember | mctree.TypedIdentifier | mctree.EnumDeclaration;
 export declare type StateNodeDecls = {

package/build/src/optimizer.d.ts

@@ -2,8 +2,8 @@ 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";
 import { BuildConfig, FilesToOptimizeMap, ProgramStateAnalysis } from "./optimizer-types";
+import { copyRecursiveAsNeeded } from "./util";
 export * from "./optimizer-types";
 export { copyRecursiveAsNeeded, get_jungle, launchSimulator, manifestProducts, mctree, ResolvedJungle, simulateProgram, };
 export declare const defaultConfig: {
@@ -18,6 +18,19 @@ declare global {
     var lastModifiedSource: number;
 }
 /**
+ *
+ * WARNING WARNING WARNING WARNING WARNING WARNING
+ *
+ * prettier-extension-monkeyc can dynamically import this
+ * function from a local copy of @markw65/monkeyc-optimizer,
+ * rather than using the version that ships with the
+ * extension.
+ *
+ * For this to work, buildOptimizedProject's signature cannot
+ * change (or at least, can only change in a backward compatible
+ * way).
+ *
+ * DON'T CHANGE THIS FUNCTION's SIGNATURE
  *
  * @param {string | null} product
  * @param {BuildConfig} options
@@ -40,13 +53,13 @@ export declare function buildOptimizedProject(product: string | null, options: B
 }>;
 export declare function generateOptimizedProject(options: BuildConfig): Promise<{
     jungleFiles: string | undefined;
-    xml: import("./manifest").ManifestXML;
+    xml: import("./xml-util").Document;
     program: string;
     hasTests: boolean;
     diagnostics?: undefined;
 } | {
     jungleFiles: string;
-    xml: import("./manifest").ManifestXML;
+    xml: import("./xml-util").Document;
     program: string;
     hasTests: boolean;
     diagnostics: Record<string, {

package/build/src/resources.d.ts

@@ -0,0 +1,5 @@
+import { Program } from "@markw65/prettier-plugin-monkeyc/build/src/estree-types";
+import { JungleResourceMap } from "./jungles";
+import { xmlUtil } from "./sdk-util";
+export declare function visit_resources(elements: xmlUtil.Element[], parent: string | null, visitor: (e: xmlUtil.Element, module: string | null) => void, error: (e: xmlUtil.Element, parent: string | null) => void): void;
+export declare function add_resources_to_ast(ast: Program, resources: Record<string, JungleResourceMap>): void;

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

@@ -1,4 +1,5 @@
 export { readPrg, SectionKinds } from "./readprg";
+export * as xmlUtil from "./xml-util";
 export declare const isWin: boolean;
 export declare const appSupport: string;
 export declare const connectiq: string;
@@ -15,4 +16,7 @@ export declare type DeviceInfo = {
     };
 };
 export declare function getDeviceInfo(): Promise<DeviceInfo>;
-export declare function getLanguages(): Promise<any>;
+export declare function getLanguages(): Promise<{
+    id: string;
+    name: string;
+}[]>;

package/build/src/visitor.d.ts

@@ -1,3 +1,4 @@
 import { mctree } from "@markw65/prettier-plugin-monkeyc";
 import { LookupDefinition, ProgramStateAnalysis } from "./optimizer-types";
+export declare function visitorNode(node: mctree.Node): mctree.Node;
 export declare function visitReferences(state: ProgramStateAnalysis, ast: mctree.Program, name: string | null, defn: LookupDefinition[] | null | false, callback: (node: mctree.Node, results: LookupDefinition[], error: boolean) => undefined | false): void;

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

@@ -0,0 +1,139 @@
+export interface Position {
+    /** >= 0 */
+    offset: number;
+    /** >= 1 */
+    line: number;
+    /** >= 0 */
+    column: number;
+}
+export interface SourceLocation {
+    source?: string | null | undefined;
+    start: Position;
+    end: Position;
+}
+interface BaseNode {
+    type: string;
+    loc?: SourceLocation | null | undefined;
+    start?: number;
+    end?: number;
+    range?: [number, number] | undefined;
+}
+interface CharData extends BaseNode {
+    type: "chardata";
+    value: string;
+}
+interface CharRef extends BaseNode {
+    type: "charref";
+    value: number;
+    base: 10 | 16;
+}
+interface Comment extends BaseNode {
+    type: "comment";
+    value: string;
+}
+interface DocTypeDecl extends BaseNode {
+    type: "doctypedecl";
+    name: string;
+    externalID?: ExternalID;
+    intSubset?: Array<MarkupDecl | PEReference>;
+}
+interface EntityDecl extends BaseNode {
+    type: "entitydecl";
+    name: string;
+    def: XValue;
+    kind: "&" | "%";
+}
+interface XValue extends BaseNode {
+    type: "entityvalue";
+    value?: Array<string | Reference | PEReference>;
+    extid?: System;
+    ndecl?: NData;
+}
+declare type Reference = CharRef | EntityRef;
+declare type PEReference = PERef;
+declare type SystemLiteral = string;
+interface EntityRef extends BaseNode {
+    type: "entityref";
+    name: string;
+}
+interface PERef extends BaseNode {
+    type: "peref";
+    name: string;
+}
+interface NotationDecl extends BaseNode {
+    type: "notationdecl";
+    name: string;
+    id: ExternalID | PublicID;
+}
+interface PublicID extends BaseNode {
+    type: "publicid";
+    value: string;
+}
+interface NData extends BaseNode {
+    type: "ndata";
+    value: string;
+}
+declare type ExternalID = System | Public;
+declare type MarkupDecl = EntityDecl | NotationDecl | PI | Comment;
+interface System extends BaseNode {
+    type: "system";
+    value: SystemLiteral;
+}
+interface Public extends BaseNode {
+    type: "public";
+    value: SystemLiteral;
+    pubid: string;
+}
+declare type Misc = Comment | PI | CharData;
+declare type Content = Element | Reference | CData | Misc;
+export interface CData extends BaseNode {
+    type: "cdata";
+    value: string;
+}
+export interface PI extends BaseNode {
+    type: "pi";
+    name: string;
+    value: string | null;
+}
+export interface Element extends BaseNode {
+    type: "element";
+    name: string;
+    attr: Record<string, string>;
+    children?: Array<Content> | undefined;
+}
+export interface Prolog extends BaseNode {
+    type: "prolog";
+    xmldecl?: XmlDecl;
+    misc1: Misc[];
+    doctypedecl?: DocTypeDecl;
+    misc2: Misc[];
+}
+interface XmlDecl extends BaseNode {
+    type: "xmldecl";
+    version: "1.0";
+    encoding?: string[];
+    standalone?: string[];
+}
+export declare class Document {
+    prolog: Prolog;
+    body: Nodes;
+    misc: Array<Misc>;
+    constructor(prolog: Prolog, body: Nodes, misc: Array<Misc>);
+}
+export declare function elementKids(e: Element): Element[];
+declare type ElementMatcher = string | ((c: Element) => boolean);
+export declare class Nodes {
+    elements: Array<Element>;
+    constructor(elements: Element | Element[]);
+    length(): number;
+    deleteChildren(arg: ElementMatcher): void;
+    addChildren(elements: Element[]): void;
+    filter(arg: ElementMatcher): Nodes;
+    skip(name: string): Nodes;
+    children(name?: string): Nodes;
+    text(): string[];
+    attrs(): Record<string, string>[];
+}
+export declare function parseXml(content: string, fileName?: string | null): Document;
+export declare function writeXml(doc: Document): string;
+export {};