@lwc-bolts/sf2ts 0.0.1 → 0.0.3

package/lib-cjs/bundle.cjs

@@ -3,10 +3,77 @@
 var webTreeSitterSfapex = require('web-tree-sitter-sfapex');
 var xml2js = require('xml2js');
 
-/** @import Parser from "web-tree-sitter" */
-/** @import { Component, ConvertedComponent } from "../index.mjs" */
+/** @import { MapPair } from "./index.mjs" */
 
-// TOOD: Apex Continuation
+/**
+ * @typedef MapDelta
+ * @property {number | null} sourcePos
+ * @property {number} destDeltaPos
+ */
+
+/**
+ *
+ * @param {MapDelta[]} mappings
+ */
+function getMappings(mappings) {
+  // increase destination position as an aggregate
+  /** @type {MapPair[]} */
+  let filteredMappings = [];
+  let lastDestPos = 0;
+  mappings.forEach((m) => {
+    m.destDeltaPos += lastDestPos;
+    lastDestPos = m.destDeltaPos;
+    if (m.sourcePos !== null) {
+      filteredMappings.push({
+        sourcePos: m.sourcePos,
+        destPos: m.destDeltaPos,
+      });
+    }
+  });
+  return filteredMappings;
+}
+
+class PositionAwareTextBuilder {
+  /** @type {MapDelta[]} */
+  mappings = [];
+  /** @type {string[]} */
+  textParts = [];
+
+  lastTextLen = 0;
+
+  /**
+   *
+   * @param {string} text
+   * @param {number?} sourceStartPos
+   * @param {number?} sourceEndPos
+   */
+  addText(text, sourceStartPos = null, sourceEndPos = null) {
+    this.mappings.push({
+      sourcePos: sourceStartPos,
+      destDeltaPos: this.lastTextLen,
+    });
+    this.lastTextLen = text.length;
+    if (sourceEndPos != null) {
+      this.mappings.push({
+        sourcePos: sourceEndPos,
+        destDeltaPos: this.lastTextLen,
+      });
+      this.lastTextLen = 0;
+    }
+    this.textParts.push(text);
+  }
+
+  build() {
+    return this.textParts.join("");
+  }
+
+  getMappings() {
+    return getMappings(this.mappings);
+  }
+}
+
+/** @import Parser from "web-tree-sitter" */
+/** @import { Component, ConvertedComponent, MapPair } from "../index.mjs" */
 
 /** @type { Parser } */
 let prsr;
@@ -29,33 +96,25 @@ function ApexClass(comp) {
     throw err;
   }
 
-  const [className, declarationContent, mappingContent] =
-    buildDeclarationForApexFile(prsr, comp.path, comp.content, false);
+  const [declarationContent, mappingContent] = buildDeclarationForApexFile(
+    prsr,
+    comp.content,
+    false
+  );
   if (declarationContent === undefined) {
     throw new Error("Problem building declaration content");
   }
+  if (mappingContent === undefined) {
+    throw new Error("Problem building declaration content mappings");
+  }
 
-  return { ...comp, declarationContent: declarationContent, mapData: [] };
+  return {
+    ...comp,
+    declarationContent: declarationContent,
+    mapData: mappingContent,
+  };
 }
 
-/**
- * @typedef DeltaPoint
- * @property {number} rowDelta
- * @property {number} column
- */
-
-/**
- * @typedef MappingPos
- * @property {DeltaPoint} startPosition
- * @property {DeltaPoint} endPosition
- */
-
-/**
- * @typedef Mapping
- * @property { MappingPos } dPos
- * @property { {startPosition: Parser.Point, endPosition: Parser.Point }?} sPos
- */
-
 /** @type { Record<string, string> } */
 const typeOverrides = {
   string: "string",
@@ -71,20 +130,22 @@ let localNestedClasses = [];
 /** @type { string? } */
 let outerClassName;
 
+// TODO: probably don't want this to be a global
+let builder = new PositionAwareTextBuilder();
+
 /**
  *
  * @param {Parser} parser
- * @param {string} relativeFilePath
  * @param {string} apexText
  * @param {boolean} isSobject
- * @returns { string[] }
+ * @returns { [string, MapPair[]] | [] }
  */
 function buildDeclarationForApexFile(
   parser,
-  relativeFilePath,
   apexText,
   isSobject = false
 ) {
+  builder = new PositionAwareTextBuilder();
   try {
     const tree = parser.parse(apexText);
     // step into top-level class, if any
@@ -95,15 +156,10 @@ function buildDeclarationForApexFile(
       return []; // this isn't a class
     }
 
-    // TODO: build mapping file
-    const [className, declarationText, mappings] = processClass(
-      classes[0],
-      isSobject
-    );
-    const mappingText = getMapFile(className, relativeFilePath, mappings);
+    processClass(classes[0], isSobject);
     localNestedClasses = [];
     outerClassName = null;
-    return [className, declarationText, mappingText];
+    return [builder.build(), builder.getMappings()];
   } catch (error) {
     console.error(error);
 
@@ -117,20 +173,19 @@ function buildDeclarationForApexFile(
  *
  * @param {Parser.SyntaxNode} classNode
  * @param {boolean} isSobject
- * @returns { [string, string, Mapping[]] }
  */
 function processClass(classNode, isSobject) {
-  let className = classNode.childForFieldName("name")?.text ?? "";
+  const classNameNode = classNode.childForFieldName("name");
+  if (!classNameNode) {
+    throw new Error("Class Name Node not found");
+  }
+  let className = classNameNode?.text ?? "";
   if (!outerClassName) {
     outerClassName = className;
   }
   let classBody = classNode.childForFieldName("body");
-  /** @type {Mapping[]} */
-  const mappings = [];
-  /** @type {string[]} */
-  let outputText = [];
   if (!classBody) {
-    return [className, outputText.join(""), mappings];
+    return;
   }
 
   const methodsToProcess = [];
@@ -157,194 +212,85 @@ function processClass(classNode, isSobject) {
     }
   }
   if (fieldsToProcess.length > 0) {
-    outputText.push(`declare interface ${className} {\n`);
-    mappings.push({
-      dPos: {
-        startPosition: {
-          rowDelta: 0,
-          column: 0,
-        },
-        endPosition: {
-          rowDelta: 0,
-          column: 0,
-        },
-      },
-      sPos: null,
-    });
+    builder.addText("declare interface ");
+    builder.addText(
+      className,
+      classNameNode.startIndex,
+      classNameNode.endIndex
+    );
+    builder.addText(" {\n");
     for (let fNode of fieldsToProcess) {
-      const [newOutputText, newMappings] = transformFieldDeclaration(
-        fNode,
-        isSobject
-      );
-      outputText.push(newOutputText);
-      mappings.push(...newMappings);
+      transformFieldDeclaration(fNode, isSobject);
     }
-    outputText.push("}\n");
-    mappings.push({
-      dPos: {
-        startPosition: {
-          rowDelta: 1,
-          column: 0,
-        },
-        endPosition: {
-          rowDelta: 0,
-          column: 0,
-        },
-      },
-      sPos: null,
-    });
+    builder.addText("}\n");
   }
 
   if (classesToProcess.length > 0) {
-    outputText.push(`declare namespace ${className} {\n`);
-    mappings.push({
-      dPos: {
-        startPosition: {
-          rowDelta: 2,
-          column: 0,
-        },
-        endPosition: {
-          rowDelta: 0,
-          column: 0,
-        },
-      },
-      sPos: null,
-    });
+    builder.addText("declare namespace ");
+    builder.addText(
+      className,
+      classNameNode.startIndex,
+      classNameNode.endIndex
+    );
+    builder.addText(" {\n");
     for (const cNode of classesToProcess) {
-      const [className, newOutputText, newMappings] = processClass(
-        cNode,
-        isSobject
-      );
-      if (newOutputText.length > 0) {
-        outputText.push("  " + newOutputText.replaceAll(/\n(.)/g, "\n  $1"));
-        mappings.push(...newMappings);
-      }
+      processClass(cNode, isSobject);
       // TODO: somehow queue up local classes for type resolution
     }
 
-    outputText.push(`}\n`);
-    mappings.push({
-      dPos: {
-        startPosition: {
-          rowDelta: 2,
-          column: 0,
-        },
-        endPosition: {
-          rowDelta: 0,
-          column: 0,
-        },
-      },
-      sPos: null,
-    });
+    builder.addText("}\n");
   }
 
   for (const mNode of methodsToProcess) {
-    const [newOutputText, newMappings] = transformMethodDeclaration(
-      className,
-      mNode
-    );
-    outputText.push(newOutputText);
-    mappings.push(...newMappings);
+    transformMethodDeclaration(classNameNode, mNode);
   }
-  return [className, outputText.join(""), mappings];
 }
 
 /**
  *
- * @param {string} className
+ * @param {Parser.SyntaxNode} classNameNode
  * @param {Parser.SyntaxNode} methodNode
- * @returns {[string, Mapping[]]}
  */
-function transformMethodDeclaration(className, methodNode) {
-  /** @type {Mapping[]} */
-  const mappings = [];
+function transformMethodDeclaration(classNameNode, methodNode) {
   const methodNameNode = methodNode.childForFieldName("name");
   if (!methodNameNode) {
-    return ["", mappings];
+    return;
   }
-  const methodName = methodNameNode.text;
+  methodNameNode.text;
   const returnType = methodNode.childForFieldName("type");
   if (!returnType) {
-    return ["", mappings];
+    return;
   }
   const parameters = getMethodParameters(methodNode);
 
   const auraEnabledNode = getAuraEnabledAnnotation(methodNode);
   if (!auraEnabledNode) {
     // method doesn't hold the AuraEnabled Annotation
-    return ["", mappings];
+    return;
   }
   const isCacheableEnabled = getAuraEnabledIsCacheable(auraEnabledNode);
+  const isContinuation = getAuraEnabledIsContinuation(auraEnabledNode);
 
-  const [newOutputText, methodNameMapping] = declarationString(
-    className,
-    methodName,
+  // TODO: continuation return type is actually the return type of the `continuationMethod` referenced in the Continuation object
+  declarationString(
+    classNameNode,
+    methodNameNode,
     getType(returnType),
     parameters,
-    isCacheableEnabled
+    isCacheableEnabled,
+    isContinuation
   );
-  const declarationParts = newOutputText.split("\n");
-  methodNameMapping.rowDelta;
-
-  mappings.push({
-    dPos: {
-      startPosition: methodNameMapping,
-      endPosition: {
-        rowDelta: methodNameMapping.rowDelta,
-        column: methodNameMapping.column + methodName.length,
-      },
-    },
-    sPos: {
-      startPosition: methodNameNode.startPosition,
-      endPosition: methodNameNode.endPosition,
-    },
-  });
-  // add consumption of remaining lines
-  mappings.push({
-    dPos: {
-      startPosition: {
-        rowDelta: declarationParts.length - methodNameMapping.rowDelta,
-        column: 0,
-      },
-      endPosition: {
-        rowDelta: declarationParts.length - methodNameMapping.rowDelta,
-        column: 0,
-      },
-    },
-    sPos: null,
-  });
-  return [newOutputText, mappings];
 }
 
 /**
  *
  * @param {Parser.SyntaxNode} node
  * @param {boolean} isSobject
- * @returns {[string, Mapping[]]}
  */
 function transformFieldDeclaration(node, isSobject) {
   /** @type {string[]} */
   let deprecatedReasons = [];
-  let output = "";
   const modifiers = node.descendantsOfType("modifiers");
-  /** @type {Mapping} */
-  const mapping = {
-    dPos: {
-      startPosition: {
-        rowDelta: 1,
-        column: 2,
-      },
-      endPosition: {
-        // TODO
-        rowDelta: 0,
-        column: 0,
-      },
-    },
-    sPos: {
-      startPosition: node.startPosition,
-      endPosition: node.endPosition,
-    },
-  };
 
   if (modifiers.length === 0 || !modifiers[0]) {
     deprecatedReasons.push("public or global");
@@ -377,21 +323,38 @@ function transformFieldDeclaration(node, isSobject) {
       deprecatedReasons.push("public or global");
     }
   }
-  /** TODO:
+  /**
    * determine if AuraEnabled & public or global & not static
    * otherwise mark as deprecated with note (dynamic based on missing access component)
    * {property}: {getType({type})}?;
    */
   if (deprecatedReasons.length > 0) {
-    mapping.dPos.startPosition.rowDelta++;
-    output += `  /** @deprecated not exposed; property must be ${deprecatedReasons.join(
-      ", "
-    )} */\n`;
-  }
-  output += `  ${
-    node.childForFieldName("declarator")?.childForFieldName("name")?.text ?? ""
-  }?: ${getType(node.childForFieldName("type"))};\n`;
-  return [output, [mapping]];
+    builder.addText(
+      `  /** @deprecated not exposed; property must be ${deprecatedReasons.join(
+        ", "
+      )} */\n`
+    );
+  }
+  const nameNode = node
+    .childForFieldName("declarator")
+    ?.childForFieldName("name");
+  builder.addText("  ");
+  if (!nameNode) {
+    throw new Error("Field doesn't have a name");
+  }
+  builder.addText(
+    `${nameNode?.text ?? ""}`,
+    nameNode.startIndex,
+    nameNode.endIndex
+  );
+  builder.addText("?: ");
+  const typeNode = node.childForFieldName("type");
+  if (!typeNode) {
+    throw new Error("Type node not found");
+  }
+  const typeText = getType(typeNode);
+  builder.addText(typeText, typeNode.startIndex, typeNode.endIndex);
+  builder.addText(";\n");
 }
 
 /**
@@ -418,6 +381,30 @@ function getAuraEnabledIsCacheable(node) {
   return false;
 }
 
+/**
+ *
+ * @param {Parser.SyntaxNode} node
+ * @returns {boolean}
+ */
+function getAuraEnabledIsContinuation(node) {
+  const args = node.childForFieldName("arguments");
+  if (args) {
+    for (const a of args.descendantsOfType("annotation_key_value")) {
+      const k = a.childForFieldName("key");
+      const v = a.childForFieldName("value");
+      if (
+        k &&
+        v &&
+        k.text.toLowerCase() === "continuation" &&
+        v.text.toLowerCase() === "true"
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 /**
  *
  * @param {Parser.SyntaxNode} node
@@ -456,22 +443,36 @@ function getMethodParameters(node) {
 
 /**
  *
- * @param {string} className
- * @param {string} methodName
+ * @param {Parser.SyntaxNode} classNameNode
+ * @param {Parser.SyntaxNode} methodNameNode
  * @param {string} returnType
  * @param {Map<string, string>} params
  * @param {boolean} isCacheable
- * @returns {[string, DeltaPoint]}
+ * @param {boolean} isContinuation
  */
 function declarationString(
-  className,
-  methodName,
+  classNameNode,
+  methodNameNode,
   returnType,
   params,
-  isCacheable
+  isCacheable,
+  isContinuation
 ) {
-  let text = `declare module "@salesforce/apex/${className}.${methodName}" {
-  const ${methodName}: {
+  builder.addText("declare module ");
+  // if method has Containuation
+  builder.addText(
+    `"@salesforce/apex${isContinuation ? "Continuation" : ""}/${classNameNode.text}.${methodNameNode.text}"`,
+    methodNameNode.startIndex,
+    methodNameNode.endIndex
+  );
+  builder.addText(` {
+  const `);
+  builder.addText(
+    methodNameNode.text,
+    methodNameNode.startIndex,
+    methodNameNode.endIndex
+  );
+  builder.addText(`: {
     (${
       params.size === 0
         ? ""
@@ -496,62 +497,9 @@ function declarationString(
     >;`
     }
   };
-  export default `;
-  // analyze how much text we're adding before the method name
-  const lines = text.split("\n");
-  /** @type {DeltaPoint} */
-  const m = {
-    rowDelta: lines.length - 1,
-    column: lines[lines.length - 1]?.length ?? 0,
-  };
-  // finish building
-  text += `${methodName};
+  export default ${methodNameNode.text};
 }
-`;
-  return [text, m];
-}
-
-/**
- *
- * @param {string} className
- * @param {string} relativeClassPath
- * @param {Mapping[]} mappings
- * @returns
- */
-function getMapFile(className, relativeClassPath, mappings) {
-  let mappingsString = "";
-  for (const m of mappings) {
-    mappingsString += ";".repeat(m.dPos.startPosition.rowDelta);
-    if (!m.sPos) {
-      continue;
-    }
-    /**
-     * Generated column
-     * Original file this appeared in
-     * Original line number relative to last given value in this field
-     * Original column relative to last given value in this field
-     */
-    // const incrementalColumnCount =
-    //   m.sPos.startPosition.column - lastMethodColumnNum;
-
-    // mappingsString += `${encode(m.dPos.startPosition.column)}${encode(
-    //   0
-    // )}${encode(m.sPos.startPosition.row - lastSourceRow)}${encode(
-    //   incrementalColumnCount
-    // )}`;
-
-    m.sPos.startPosition.column;
-    m.sPos.startPosition.row;
-  }
-  return JSON.stringify({
-    version: 3,
-    file: `${className}.d.ts`,
-    sourceRoot: "",
-    // TODO: not so badly hardcoded
-    sources: [`../../../../../${relativeClassPath}`],
-    names: [],
-    mappings: mappingsString,
-  });
+`);
 }
 
 /**
@@ -608,11 +556,34 @@ function ContentAsset(component) {
     }
     asset = result;
   });
-  const dec = `declare module "@salesforce/contentAssetUrl/${asset.ContentAsset.masterLabel}" {
-  var ${asset.ContentAsset.masterLabel}: string;
-  export default ${asset.ContentAsset.masterLabel};
-}`;
-  return { declarationContent: dec, mapData: [], ...component };
+  const label = asset.ContentAsset.masterLabel[0];
+  const namePosStart =
+    component.content.indexOf("<masterLabel>") + "<masterLabel>".length;
+  const namePosEnd = namePosStart + label.length;
+
+  const builder = new PositionAwareTextBuilder();
+
+  builder.addText(`declare module `);
+  builder.addText(
+    `"@salesforce/contentAssetUrl/${label}"`,
+    namePosStart,
+    namePosEnd
+  );
+  builder.addText(
+    ` {
+  const `
+  );
+  builder.addText(label, namePosStart, namePosEnd);
+  builder.addText(
+    `: string;
+  export default ${label};
+}`
+  );
+  return {
+    declarationContent: builder.build(),
+    mapData: builder.getMappings(),
+    ...component,
+  };
 }
 
 /** @import { Component, ConvertedComponent } from "../index.mjs" */
@@ -623,7 +594,6 @@ function ContentAsset(component) {
  * @returns {ConvertedComponent}
  */
 function CustomPermission(component) {
-  // generate d.ts
   /** @type {any} */
   let perm;
   xml2js.parseString(component.content, (error, result) => {
@@ -633,16 +603,37 @@ function CustomPermission(component) {
     perm = result;
   });
   const permName = component.path.split("/").pop()?.split(".")[0];
-  const dec = `declare module "@salesforce/customPermission/${permName}" {
+  const namePosStart = component.content.indexOf("<label>") + "<label>".length;
+  const namePosEnd = component.content.indexOf("</label>");
+
+  const builder = new PositionAwareTextBuilder();
+  builder.addText("declare module ");
+  builder.addText(
+    `"@salesforce/customPermission/${permName}"`,
+    namePosStart,
+    namePosEnd
+  );
+
+  builder.addText(
+    ` {
   /**
    * ${perm.CustomPermission.label}
    *
    * @description ${perm.CustomPermission.description}
    */
-  const has${permName}:boolean;
+  const `
+  );
+  builder.addText(`has${permName}`, namePosStart, namePosEnd);
+  builder.addText(
+    `:boolean;
   export default has${permName};
-}`;
-  return { declarationContent: dec, mapData: [], ...component };
+}`
+  );
+  return {
+    declarationContent: builder.build(),
+    mapData: builder.getMappings(),
+    ...component,
+  };
 }
 
 /** @import { Component, ConvertedComponent } from "../index.mjs" */
@@ -664,20 +655,47 @@ function CustomField(component) {
   });
   const pathParts = component.path.split("/");
   const fieldName = pathParts.pop()?.split(".")[0];
+  if (!fieldName) {
+    throw new Error("Unable to resolve field name from file path");
+  }
   pathParts?.pop(); // discard `fields`
   const objectName = pathParts.pop();
-  const dec = `declare module '@salesforce/schema/${objectName}.${fieldName}' {
+
+  const namePosStart =
+    component.content.indexOf("<fullName>") + "<fullName>".length;
+  const namePosEnd = namePosStart + fieldName.length;
+
+  const builder = new PositionAwareTextBuilder();
+  builder.addText(`declare module `);
+  builder.addText(
+    `"@salesforce/schema/${objectName}.${fieldName}"`,
+    namePosStart,
+    namePosEnd
+  );
+  builder.addText(
+    ` {
   /**
    * @description ${field.CustomField.inlineHelpText}
    * @description ${field.CustomField.description}
    */
-  const ${fieldName}: {
+  const `
+  );
+
+  builder.addText(`${fieldName}`, namePosStart, namePosEnd);
+
+  builder.addText(
+    `: {
     fieldApiName: '${fieldName}';
     objectApiName: '${objectName}';
   }
   export default ${fieldName};
-}`;
-  return { declarationContent: dec, mapData: [], ...component };
+}`
+  );
+  return {
+    declarationContent: builder.build(),
+    mapData: builder.getMappings(),
+    ...component,
+  };
 }
 
 /** @import { Component, ConvertedComponent } from "../index.mjs" */
@@ -700,18 +718,40 @@ function CustomLabels(component) {
   if (!Array.isArray(labels.CustomLabels.labels)) {
     labels.CustomLabels.labels = [labels.CustomLabels.labels];
   }
-  let dec = "";
+
+  const builder = new PositionAwareTextBuilder();
   for (let label of labels.CustomLabels.labels) {
-    dec += `declare module "@salesforce/label/c.${label.fullName}" {
+    const labelName = label.fullName[0];
+    const namePosStart =
+      component.content.indexOf(`<fullName>${labelName}`) + `<fullName>`.length;
+    const namePosEnd = namePosStart + labelName.length;
+
+    builder.addText(`declare module `);
+    builder.addText(
+      `"@salesforce/label/c.${labelName}"`,
+      namePosStart,
+      namePosEnd
+    );
+    builder.addText(
+      ` {
   /**
    * @description ${label.shortDescription}
    */
-  const lbl${label.fullName} = '${label.value}';
+  const `
+    );
+    builder.addText(`lbl${label.fullName}`, namePosStart, namePosEnd);
+    builder.addText(
+      ` = '${label.value}';
   export default lbl${label.fullName};
 }
-`;
+`
+    );
   }
-  return { declarationContent: dec, mapData: [], ...component };
+  return {
+    declarationContent: builder.build(),
+    mapData: builder.getMappings(),
+    ...component,
+  };
 }
 
 /** @import { Component, ConvertedComponent } from "../index.mjs" */
@@ -732,16 +772,36 @@ function CustomObject(component) {
     obj = result;
   });
   const objectName = component.path.split("/").pop()?.split(".")[0];
-  const dec = `declare module '@salesforce/schema/${objectName}' {
+  if (!objectName) {
+    throw new Error("Unable to find Object Name");
+  }
+
+  const namePos = component.content.indexOf("<label>") + "<label>".length;
+  const namePosEnd = component.content.indexOf("</label>");
+
+  const builder = new PositionAwareTextBuilder();
+  builder.addText(`declare module `);
+  builder.addText(`"@salesforce/schema/${objectName}"`, namePos, namePosEnd);
+  builder.addText(
+    ` {
   /**
    * @description ${obj.CustomObject.description}
    */
-  const ${objectName}: {
+  const `
+  );
+  builder.addText(`${objectName}`, namePos, namePosEnd);
+  builder.addText(
+    `: {
       objectApiName: '${objectName}';
   }
   export default ${objectName};
-}`;
-  return { declarationContent: dec, mapData: [], ...component };
+}`
+  );
+  return {
+    declarationContent: builder.build(),
+    mapData: builder.getMappings(),
+    ...component,
+  };
 }
 
 /** @import { Component, ConvertedComponent } from "../index.mjs" */
@@ -762,15 +822,41 @@ function StaticResource(component) {
     resource = result;
   });
   const resourceName = component.path.split("/").pop()?.split(".")[0];
-  const dec = `declare module "@salesforce/resourceUrl/${resourceName}" {
+  const namePosStart =
+    component.content.indexOf("<description>") + "<description>".length;
+  const namePosEnd = component.content.indexOf("</description>");
+
+  const builder = new PositionAwareTextBuilder();
+
+  builder.addText("declare module ");
+
+  builder.addText(
+    `"@salesforce/resourceUrl/${resourceName}"`,
+    namePosStart,
+    namePosEnd
+  );
+
+  builder.addText(
+    ` {
   /**
    * @description ${resource.StaticResource.description}
    * @access ${resource.StaticResource.cacheControl}
    */
-  const ${resourceName}:string;
+  const `
+  );
+
+  builder.addText(`${resourceName}`, namePosStart, namePosEnd);
+
+  builder.addText(
+    `:string;
   export default ${resourceName};
-}`;
-  return { declarationContent: dec, mapData: [], ...component };
+}`
+  );
+  return {
+    declarationContent: builder.build(),
+    mapData: builder.getMappings(),
+    ...component,
+  };
 }
 
 var converters = /*#__PURE__*/Object.freeze({