@platforma-sdk/tengo-builder 4.1.1 → 4.1.3

package/dist/compiler/imports.cjs

@@ -16,14 +16,26 @@ function escapeForRegExp(s) {
 /**
 * Find imports the source does not use.
 *
-* An import is used when its alias appears with a dot somewhere else in the
-* code: 'text.split(...)'. A module passed around as a value, say
-* 'myFunc(text)', counts as unused. This is deliberate: the cost of keeping an
-* import the source no longer needs is nothing, while the cost of dropping one
-* it does need is a broken build.
+* An import counts as used when its alias appears elsewhere in the code as a
+* name of its own. Three shapes count:
 *
-* Throws when the source does not parse, with the same line context the
-* compiler reports.
+* - dereferenced: 'text.split(x)'
+* - called: 'doIt(x)', for a lib that exports a bare function
+* - passed as a value: 'myFunc(text)'
+*
+* Two shapes do not count. A longer name that ends with the alias ('xtext') is
+* a different name. A declaration that shadows the alias ('text := ...') binds
+* the name. It does not read the import.
+*
+* Every other occurrence counts. This includes a member of another value
+* ('opts.text') and text inside a string literal ('"a text file"'). The check
+* is wide on purpose. An import that the source no longer needs costs nothing.
+* A dropped import that the source needs breaks the build. The predicate must
+* stay wider than every earlier predicate. A release then reports fewer unused
+* imports, and never more.
+*
+* Throws when the source does not parse. The error carries the same line
+* context that the compiler reports.
 */
 function findUnusedImports(logger, src, localPackageName, srcName) {
 	const imports = [];
@@ -46,7 +58,7 @@ function findUnusedImports(logger, src, localPackageName, srcName) {
 		}
 	}
 	return imports.filter((im) => {
-		const usageRE = new RegExp(`\\b${escapeForRegExp(im.alias)}\\s*\\.`);
+		const usageRE = new RegExp(`(?<!\\w)${escapeForRegExp(im.alias)}\\b(?!\\s*:=)`);
 		return !codeLines.some((code, lineNo) => lineNo !== im.lineNo && usageRE.test(code));
 	});
 }

package/dist/compiler/imports.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"imports.cjs","names":["parseSingleSourceLine"],"sources":["../../src/compiler/imports.ts"],"sourcesContent":["// Unused import detection for Tengo sources.\n//\n// The check runs on the parser's own line results, not on the raw text: a\n// comment line comes back empty, so an alias that appears only in a comment\n// correctly counts as unused.\n\nimport type { MiLogger } from \"@milaboratories/ts-helpers\";\nimport type { ImportInfo, sourceParserContext } from \"./source\";\nimport { parseSingleSourceLine } from \"./source\";\n\n/** A module import statement and the line it is on. */\nexport type TengoImport = ImportInfo & {\n  /** Line index in the source, counted from 0. */\n  lineNo: number;\n};\n\nfunction newParserContext(): sourceParserContext {\n  return {\n    isInCommentBlock: false,\n    canDetectOptions: true,\n    artifactImportREs: new Map(),\n    importLikeREs: new Map(),\n    multilineStatement: \"\",\n    lineNo: 0,\n  };\n}\n\nfunction escapeForRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\n/**\n * Find imports the source does not use.\n *\n * An import is used when its alias appears with a dot somewhere else in the\n * code: 'text.split(...)'. A module passed around as a value, say\n * 'myFunc(text)', counts as unused. This is deliberate: the cost of keeping an\n * import the source no longer needs is nothing, while the cost of dropping one\n * it does need is a broken build.\n *\n * Throws when the source does not parse, with the same line context the\n * compiler reports.\n */\nexport function findUnusedImports(\n  logger: MiLogger,\n  src: string,\n  localPackageName: string,\n  srcName: string,\n): TengoImport[] {\n  const imports: TengoImport[] = [];\n\n  // Lines as the parser sees them: comments are empty, code is untouched.\n  const codeLines: string[] = [];\n\n  let context = newParserContext();\n\n  const lines = src.split(\"\\n\");\n  for (const line of lines) {\n    context.lineNo++;\n\n    try {\n      const result = parseSingleSourceLine(logger, line, context, localPackageName, false);\n      context = result.context;\n      codeLines.push(result.line);\n\n      if (result.moduleImport) {\n        imports.push({ ...result.moduleImport, lineNo: context.lineNo - 1 });\n      }\n    } catch (error: unknown) {\n      const err = error as Error;\n      throw new Error(`[line ${context.lineNo} in ${srcName}]: ${err.message}\\n\\t${line}`, {\n        cause: err,\n      });\n    }\n  }\n\n  return imports.filter((im) => {\n    const usageRE = new RegExp(`\\\\b${escapeForRegExp(im.alias)}\\\\s*\\\\.`);\n    return !codeLines.some((code, lineNo) => lineNo !== im.lineNo && usageRE.test(code));\n  });\n}\n\n/**\n * Drop the given lines from the source.\n *\n * The source is cut as it was written: comments, blank lines and formatting\n * outside the dropped lines stay byte for byte the same. An import is always a\n * single line, as the parser accepts it only as an assignment.\n */\nexport function dropImportLines(src: string, lineNos: number[]): string {\n  const drop = new Set(lineNos);\n  return src\n    .split(\"\\n\")\n    .filter((_, lineNo) => !drop.has(lineNo))\n    .join(\"\\n\");\n}\n"],"mappings":";;AAgBA,SAAS,mBAAwC;CAC/C,OAAO;EACL,kBAAkB;EAClB,kBAAkB;EAClB,mCAAmB,IAAI,IAAI;EAC3B,+BAAe,IAAI,IAAI;EACvB,oBAAoB;EACpB,QAAQ;CACV;AACF;AAEA,SAAS,gBAAgB,GAAmB;CAC1C,OAAO,EAAE,QAAQ,uBAAuB,MAAM;AAChD;;;;;;;;;;;;;AAcA,SAAgB,kBACd,QACA,KACA,kBACA,SACe;CACf,MAAM,UAAyB,CAAC;CAGhC,MAAM,YAAsB,CAAC;CAE7B,IAAI,UAAU,iBAAiB;CAE/B,MAAM,QAAQ,IAAI,MAAM,IAAI;CAC5B,KAAK,MAAM,QAAQ,OAAO;EACxB,QAAQ;EAER,IAAI;GACF,MAAM,SAASA,eAAAA,sBAAsB,QAAQ,MAAM,SAAS,kBAAkB,KAAK;GACnF,UAAU,OAAO;GACjB,UAAU,KAAK,OAAO,IAAI;GAE1B,IAAI,OAAO,cACT,QAAQ,KAAK;IAAE,GAAG,OAAO;IAAc,QAAQ,QAAQ,SAAS;GAAE,CAAC;EAEvE,SAAS,OAAgB;GACvB,MAAM,MAAM;GACZ,MAAM,IAAI,MAAM,SAAS,QAAQ,OAAO,MAAM,QAAQ,KAAK,IAAI,QAAQ,MAAM,QAAQ,EACnF,OAAO,IACT,CAAC;EACH;CACF;CAEA,OAAO,QAAQ,QAAQ,OAAO;EAC5B,MAAM,UAAU,IAAI,OAAO,MAAM,gBAAgB,GAAG,KAAK,EAAE,QAAQ;EACnE,OAAO,CAAC,UAAU,MAAM,MAAM,WAAW,WAAW,GAAG,UAAU,QAAQ,KAAK,IAAI,CAAC;CACrF,CAAC;AACH;;;;;;;;AASA,SAAgB,gBAAgB,KAAa,SAA2B;CACtE,MAAM,OAAO,IAAI,IAAI,OAAO;CAC5B,OAAO,IACJ,MAAM,IAAI,CAAC,CACX,QAAQ,GAAG,WAAW,CAAC,KAAK,IAAI,MAAM,CAAC,CAAC,CACxC,KAAK,IAAI;AACd"}
+{"version":3,"file":"imports.cjs","names":["parseSingleSourceLine"],"sources":["../../src/compiler/imports.ts"],"sourcesContent":["// Unused import detection for Tengo sources.\n//\n// The check runs on the parser's own line results, not on the raw text: a\n// comment line comes back empty, so an alias that appears only in a comment\n// correctly counts as unused.\n\nimport type { MiLogger } from \"@milaboratories/ts-helpers\";\nimport type { ImportInfo, sourceParserContext } from \"./source\";\nimport { parseSingleSourceLine } from \"./source\";\n\n/** A module import statement and the line it is on. */\nexport type TengoImport = ImportInfo & {\n  /** Line index in the source, counted from 0. */\n  lineNo: number;\n};\n\nfunction newParserContext(): sourceParserContext {\n  return {\n    isInCommentBlock: false,\n    canDetectOptions: true,\n    artifactImportREs: new Map(),\n    importLikeREs: new Map(),\n    multilineStatement: \"\",\n    lineNo: 0,\n  };\n}\n\nfunction escapeForRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\n/**\n * Find imports the source does not use.\n *\n * An import counts as used when its alias appears elsewhere in the code as a\n * name of its own. Three shapes count:\n *\n * - dereferenced: 'text.split(x)'\n * - called: 'doIt(x)', for a lib that exports a bare function\n * - passed as a value: 'myFunc(text)'\n *\n * Two shapes do not count. A longer name that ends with the alias ('xtext') is\n * a different name. A declaration that shadows the alias ('text := ...') binds\n * the name. It does not read the import.\n *\n * Every other occurrence counts. This includes a member of another value\n * ('opts.text') and text inside a string literal ('\"a text file\"'). The check\n * is wide on purpose. An import that the source no longer needs costs nothing.\n * A dropped import that the source needs breaks the build. The predicate must\n * stay wider than every earlier predicate. A release then reports fewer unused\n * imports, and never more.\n *\n * Throws when the source does not parse. The error carries the same line\n * context that the compiler reports.\n */\nexport function findUnusedImports(\n  logger: MiLogger,\n  src: string,\n  localPackageName: string,\n  srcName: string,\n): TengoImport[] {\n  const imports: TengoImport[] = [];\n\n  // Lines as the parser sees them: comments are empty, code is untouched.\n  const codeLines: string[] = [];\n\n  let context = newParserContext();\n\n  const lines = src.split(\"\\n\");\n  for (const line of lines) {\n    context.lineNo++;\n\n    try {\n      const result = parseSingleSourceLine(logger, line, context, localPackageName, false);\n      context = result.context;\n      codeLines.push(result.line);\n\n      if (result.moduleImport) {\n        imports.push({ ...result.moduleImport, lineNo: context.lineNo - 1 });\n      }\n    } catch (error: unknown) {\n      const err = error as Error;\n      throw new Error(`[line ${context.lineNo} in ${srcName}]: ${err.message}\\n\\t${line}`, {\n        cause: err,\n      });\n    }\n  }\n\n  return imports.filter((im) => {\n    const usageRE = new RegExp(`(?<!\\\\w)${escapeForRegExp(im.alias)}\\\\b(?!\\\\s*:=)`);\n    return !codeLines.some((code, lineNo) => lineNo !== im.lineNo && usageRE.test(code));\n  });\n}\n\n/**\n * Drop the given lines from the source.\n *\n * The source is cut as it was written: comments, blank lines and formatting\n * outside the dropped lines stay byte for byte the same. An import is always a\n * single line, as the parser accepts it only as an assignment.\n */\nexport function dropImportLines(src: string, lineNos: number[]): string {\n  const drop = new Set(lineNos);\n  return src\n    .split(\"\\n\")\n    .filter((_, lineNo) => !drop.has(lineNo))\n    .join(\"\\n\");\n}\n"],"mappings":";;AAgBA,SAAS,mBAAwC;CAC/C,OAAO;EACL,kBAAkB;EAClB,kBAAkB;EAClB,mCAAmB,IAAI,IAAI;EAC3B,+BAAe,IAAI,IAAI;EACvB,oBAAoB;EACpB,QAAQ;CACV;AACF;AAEA,SAAS,gBAAgB,GAAmB;CAC1C,OAAO,EAAE,QAAQ,uBAAuB,MAAM;AAChD;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,kBACd,QACA,KACA,kBACA,SACe;CACf,MAAM,UAAyB,CAAC;CAGhC,MAAM,YAAsB,CAAC;CAE7B,IAAI,UAAU,iBAAiB;CAE/B,MAAM,QAAQ,IAAI,MAAM,IAAI;CAC5B,KAAK,MAAM,QAAQ,OAAO;EACxB,QAAQ;EAER,IAAI;GACF,MAAM,SAASA,eAAAA,sBAAsB,QAAQ,MAAM,SAAS,kBAAkB,KAAK;GACnF,UAAU,OAAO;GACjB,UAAU,KAAK,OAAO,IAAI;GAE1B,IAAI,OAAO,cACT,QAAQ,KAAK;IAAE,GAAG,OAAO;IAAc,QAAQ,QAAQ,SAAS;GAAE,CAAC;EAEvE,SAAS,OAAgB;GACvB,MAAM,MAAM;GACZ,MAAM,IAAI,MAAM,SAAS,QAAQ,OAAO,MAAM,QAAQ,KAAK,IAAI,QAAQ,MAAM,QAAQ,EACnF,OAAO,IACT,CAAC;EACH;CACF;CAEA,OAAO,QAAQ,QAAQ,OAAO;EAC5B,MAAM,UAAU,IAAI,OAAO,WAAW,gBAAgB,GAAG,KAAK,EAAE,cAAc;EAC9E,OAAO,CAAC,UAAU,MAAM,MAAM,WAAW,WAAW,GAAG,UAAU,QAAQ,KAAK,IAAI,CAAC;CACrF,CAAC;AACH;;;;;;;;AASA,SAAgB,gBAAgB,KAAa,SAA2B;CACtE,MAAM,OAAO,IAAI,IAAI,OAAO;CAC5B,OAAO,IACJ,MAAM,IAAI,CAAC,CACX,QAAQ,GAAG,WAAW,CAAC,KAAK,IAAI,MAAM,CAAC,CAAC,CACxC,KAAK,IAAI;AACd"}

package/dist/compiler/imports.js

@@ -16,14 +16,26 @@ function escapeForRegExp(s) {
 /**
 * Find imports the source does not use.
 *
-* An import is used when its alias appears with a dot somewhere else in the
-* code: 'text.split(...)'. A module passed around as a value, say
-* 'myFunc(text)', counts as unused. This is deliberate: the cost of keeping an
-* import the source no longer needs is nothing, while the cost of dropping one
-* it does need is a broken build.
+* An import counts as used when its alias appears elsewhere in the code as a
+* name of its own. Three shapes count:
 *
-* Throws when the source does not parse, with the same line context the
-* compiler reports.
+* - dereferenced: 'text.split(x)'
+* - called: 'doIt(x)', for a lib that exports a bare function
+* - passed as a value: 'myFunc(text)'
+*
+* Two shapes do not count. A longer name that ends with the alias ('xtext') is
+* a different name. A declaration that shadows the alias ('text := ...') binds
+* the name. It does not read the import.
+*
+* Every other occurrence counts. This includes a member of another value
+* ('opts.text') and text inside a string literal ('"a text file"'). The check
+* is wide on purpose. An import that the source no longer needs costs nothing.
+* A dropped import that the source needs breaks the build. The predicate must
+* stay wider than every earlier predicate. A release then reports fewer unused
+* imports, and never more.
+*
+* Throws when the source does not parse. The error carries the same line
+* context that the compiler reports.
 */
 function findUnusedImports(logger, src, localPackageName, srcName) {
 	const imports = [];
@@ -46,7 +58,7 @@ function findUnusedImports(logger, src, localPackageName, srcName) {
 		}
 	}
 	return imports.filter((im) => {
-		const usageRE = new RegExp(`\\b${escapeForRegExp(im.alias)}\\s*\\.`);
+		const usageRE = new RegExp(`(?<!\\w)${escapeForRegExp(im.alias)}\\b(?!\\s*:=)`);
 		return !codeLines.some((code, lineNo) => lineNo !== im.lineNo && usageRE.test(code));
 	});
 }

package/dist/compiler/imports.js.map

@@ -1 +1 @@
-{"version":3,"file":"imports.js","names":[],"sources":["../../src/compiler/imports.ts"],"sourcesContent":["// Unused import detection for Tengo sources.\n//\n// The check runs on the parser's own line results, not on the raw text: a\n// comment line comes back empty, so an alias that appears only in a comment\n// correctly counts as unused.\n\nimport type { MiLogger } from \"@milaboratories/ts-helpers\";\nimport type { ImportInfo, sourceParserContext } from \"./source\";\nimport { parseSingleSourceLine } from \"./source\";\n\n/** A module import statement and the line it is on. */\nexport type TengoImport = ImportInfo & {\n  /** Line index in the source, counted from 0. */\n  lineNo: number;\n};\n\nfunction newParserContext(): sourceParserContext {\n  return {\n    isInCommentBlock: false,\n    canDetectOptions: true,\n    artifactImportREs: new Map(),\n    importLikeREs: new Map(),\n    multilineStatement: \"\",\n    lineNo: 0,\n  };\n}\n\nfunction escapeForRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\n/**\n * Find imports the source does not use.\n *\n * An import is used when its alias appears with a dot somewhere else in the\n * code: 'text.split(...)'. A module passed around as a value, say\n * 'myFunc(text)', counts as unused. This is deliberate: the cost of keeping an\n * import the source no longer needs is nothing, while the cost of dropping one\n * it does need is a broken build.\n *\n * Throws when the source does not parse, with the same line context the\n * compiler reports.\n */\nexport function findUnusedImports(\n  logger: MiLogger,\n  src: string,\n  localPackageName: string,\n  srcName: string,\n): TengoImport[] {\n  const imports: TengoImport[] = [];\n\n  // Lines as the parser sees them: comments are empty, code is untouched.\n  const codeLines: string[] = [];\n\n  let context = newParserContext();\n\n  const lines = src.split(\"\\n\");\n  for (const line of lines) {\n    context.lineNo++;\n\n    try {\n      const result = parseSingleSourceLine(logger, line, context, localPackageName, false);\n      context = result.context;\n      codeLines.push(result.line);\n\n      if (result.moduleImport) {\n        imports.push({ ...result.moduleImport, lineNo: context.lineNo - 1 });\n      }\n    } catch (error: unknown) {\n      const err = error as Error;\n      throw new Error(`[line ${context.lineNo} in ${srcName}]: ${err.message}\\n\\t${line}`, {\n        cause: err,\n      });\n    }\n  }\n\n  return imports.filter((im) => {\n    const usageRE = new RegExp(`\\\\b${escapeForRegExp(im.alias)}\\\\s*\\\\.`);\n    return !codeLines.some((code, lineNo) => lineNo !== im.lineNo && usageRE.test(code));\n  });\n}\n\n/**\n * Drop the given lines from the source.\n *\n * The source is cut as it was written: comments, blank lines and formatting\n * outside the dropped lines stay byte for byte the same. An import is always a\n * single line, as the parser accepts it only as an assignment.\n */\nexport function dropImportLines(src: string, lineNos: number[]): string {\n  const drop = new Set(lineNos);\n  return src\n    .split(\"\\n\")\n    .filter((_, lineNo) => !drop.has(lineNo))\n    .join(\"\\n\");\n}\n"],"mappings":";;AAgBA,SAAS,mBAAwC;CAC/C,OAAO;EACL,kBAAkB;EAClB,kBAAkB;EAClB,mCAAmB,IAAI,IAAI;EAC3B,+BAAe,IAAI,IAAI;EACvB,oBAAoB;EACpB,QAAQ;CACV;AACF;AAEA,SAAS,gBAAgB,GAAmB;CAC1C,OAAO,EAAE,QAAQ,uBAAuB,MAAM;AAChD;;;;;;;;;;;;;AAcA,SAAgB,kBACd,QACA,KACA,kBACA,SACe;CACf,MAAM,UAAyB,CAAC;CAGhC,MAAM,YAAsB,CAAC;CAE7B,IAAI,UAAU,iBAAiB;CAE/B,MAAM,QAAQ,IAAI,MAAM,IAAI;CAC5B,KAAK,MAAM,QAAQ,OAAO;EACxB,QAAQ;EAER,IAAI;GACF,MAAM,SAAS,sBAAsB,QAAQ,MAAM,SAAS,kBAAkB,KAAK;GACnF,UAAU,OAAO;GACjB,UAAU,KAAK,OAAO,IAAI;GAE1B,IAAI,OAAO,cACT,QAAQ,KAAK;IAAE,GAAG,OAAO;IAAc,QAAQ,QAAQ,SAAS;GAAE,CAAC;EAEvE,SAAS,OAAgB;GACvB,MAAM,MAAM;GACZ,MAAM,IAAI,MAAM,SAAS,QAAQ,OAAO,MAAM,QAAQ,KAAK,IAAI,QAAQ,MAAM,QAAQ,EACnF,OAAO,IACT,CAAC;EACH;CACF;CAEA,OAAO,QAAQ,QAAQ,OAAO;EAC5B,MAAM,UAAU,IAAI,OAAO,MAAM,gBAAgB,GAAG,KAAK,EAAE,QAAQ;EACnE,OAAO,CAAC,UAAU,MAAM,MAAM,WAAW,WAAW,GAAG,UAAU,QAAQ,KAAK,IAAI,CAAC;CACrF,CAAC;AACH;;;;;;;;AASA,SAAgB,gBAAgB,KAAa,SAA2B;CACtE,MAAM,OAAO,IAAI,IAAI,OAAO;CAC5B,OAAO,IACJ,MAAM,IAAI,CAAC,CACX,QAAQ,GAAG,WAAW,CAAC,KAAK,IAAI,MAAM,CAAC,CAAC,CACxC,KAAK,IAAI;AACd"}
+{"version":3,"file":"imports.js","names":[],"sources":["../../src/compiler/imports.ts"],"sourcesContent":["// Unused import detection for Tengo sources.\n//\n// The check runs on the parser's own line results, not on the raw text: a\n// comment line comes back empty, so an alias that appears only in a comment\n// correctly counts as unused.\n\nimport type { MiLogger } from \"@milaboratories/ts-helpers\";\nimport type { ImportInfo, sourceParserContext } from \"./source\";\nimport { parseSingleSourceLine } from \"./source\";\n\n/** A module import statement and the line it is on. */\nexport type TengoImport = ImportInfo & {\n  /** Line index in the source, counted from 0. */\n  lineNo: number;\n};\n\nfunction newParserContext(): sourceParserContext {\n  return {\n    isInCommentBlock: false,\n    canDetectOptions: true,\n    artifactImportREs: new Map(),\n    importLikeREs: new Map(),\n    multilineStatement: \"\",\n    lineNo: 0,\n  };\n}\n\nfunction escapeForRegExp(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\n/**\n * Find imports the source does not use.\n *\n * An import counts as used when its alias appears elsewhere in the code as a\n * name of its own. Three shapes count:\n *\n * - dereferenced: 'text.split(x)'\n * - called: 'doIt(x)', for a lib that exports a bare function\n * - passed as a value: 'myFunc(text)'\n *\n * Two shapes do not count. A longer name that ends with the alias ('xtext') is\n * a different name. A declaration that shadows the alias ('text := ...') binds\n * the name. It does not read the import.\n *\n * Every other occurrence counts. This includes a member of another value\n * ('opts.text') and text inside a string literal ('\"a text file\"'). The check\n * is wide on purpose. An import that the source no longer needs costs nothing.\n * A dropped import that the source needs breaks the build. The predicate must\n * stay wider than every earlier predicate. A release then reports fewer unused\n * imports, and never more.\n *\n * Throws when the source does not parse. The error carries the same line\n * context that the compiler reports.\n */\nexport function findUnusedImports(\n  logger: MiLogger,\n  src: string,\n  localPackageName: string,\n  srcName: string,\n): TengoImport[] {\n  const imports: TengoImport[] = [];\n\n  // Lines as the parser sees them: comments are empty, code is untouched.\n  const codeLines: string[] = [];\n\n  let context = newParserContext();\n\n  const lines = src.split(\"\\n\");\n  for (const line of lines) {\n    context.lineNo++;\n\n    try {\n      const result = parseSingleSourceLine(logger, line, context, localPackageName, false);\n      context = result.context;\n      codeLines.push(result.line);\n\n      if (result.moduleImport) {\n        imports.push({ ...result.moduleImport, lineNo: context.lineNo - 1 });\n      }\n    } catch (error: unknown) {\n      const err = error as Error;\n      throw new Error(`[line ${context.lineNo} in ${srcName}]: ${err.message}\\n\\t${line}`, {\n        cause: err,\n      });\n    }\n  }\n\n  return imports.filter((im) => {\n    const usageRE = new RegExp(`(?<!\\\\w)${escapeForRegExp(im.alias)}\\\\b(?!\\\\s*:=)`);\n    return !codeLines.some((code, lineNo) => lineNo !== im.lineNo && usageRE.test(code));\n  });\n}\n\n/**\n * Drop the given lines from the source.\n *\n * The source is cut as it was written: comments, blank lines and formatting\n * outside the dropped lines stay byte for byte the same. An import is always a\n * single line, as the parser accepts it only as an assignment.\n */\nexport function dropImportLines(src: string, lineNos: number[]): string {\n  const drop = new Set(lineNos);\n  return src\n    .split(\"\\n\")\n    .filter((_, lineNo) => !drop.has(lineNo))\n    .join(\"\\n\");\n}\n"],"mappings":";;AAgBA,SAAS,mBAAwC;CAC/C,OAAO;EACL,kBAAkB;EAClB,kBAAkB;EAClB,mCAAmB,IAAI,IAAI;EAC3B,+BAAe,IAAI,IAAI;EACvB,oBAAoB;EACpB,QAAQ;CACV;AACF;AAEA,SAAS,gBAAgB,GAAmB;CAC1C,OAAO,EAAE,QAAQ,uBAAuB,MAAM;AAChD;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,kBACd,QACA,KACA,kBACA,SACe;CACf,MAAM,UAAyB,CAAC;CAGhC,MAAM,YAAsB,CAAC;CAE7B,IAAI,UAAU,iBAAiB;CAE/B,MAAM,QAAQ,IAAI,MAAM,IAAI;CAC5B,KAAK,MAAM,QAAQ,OAAO;EACxB,QAAQ;EAER,IAAI;GACF,MAAM,SAAS,sBAAsB,QAAQ,MAAM,SAAS,kBAAkB,KAAK;GACnF,UAAU,OAAO;GACjB,UAAU,KAAK,OAAO,IAAI;GAE1B,IAAI,OAAO,cACT,QAAQ,KAAK;IAAE,GAAG,OAAO;IAAc,QAAQ,QAAQ,SAAS;GAAE,CAAC;EAEvE,SAAS,OAAgB;GACvB,MAAM,MAAM;GACZ,MAAM,IAAI,MAAM,SAAS,QAAQ,OAAO,MAAM,QAAQ,KAAK,IAAI,QAAQ,MAAM,QAAQ,EACnF,OAAO,IACT,CAAC;EACH;CACF;CAEA,OAAO,QAAQ,QAAQ,OAAO;EAC5B,MAAM,UAAU,IAAI,OAAO,WAAW,gBAAgB,GAAG,KAAK,EAAE,cAAc;EAC9E,OAAO,CAAC,UAAU,MAAM,MAAM,WAAW,WAAW,GAAG,UAAU,QAAQ,KAAK,IAAI,CAAC;CACrF,CAAC;AACH;;;;;;;;AASA,SAAgB,gBAAgB,KAAa,SAA2B;CACtE,MAAM,OAAO,IAAI,IAAI,OAAO;CAC5B,OAAO,IACJ,MAAM,IAAI,CAAC,CACX,QAAQ,GAAG,WAAW,CAAC,KAAK,IAAI,MAAM,CAAC,CAAC,CACxC,KAAK,IAAI;AACd"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platforma-sdk/tengo-builder",
-  "version": "4.1.1",
+  "version": "4.1.3",
   "description": "Pl Tengo Template Builder",
   "license": "UNLICENSED",
   "bin": {
@@ -17,8 +17,8 @@
     "commander": "^15.0.0",
     "winston": "^3.17.0",
     "@milaboratories/resolve-helper": "1.1.3",
-    "@milaboratories/ts-helpers": "1.8.6",
-    "@milaboratories/pl-model-backend": "1.4.27"
+    "@milaboratories/pl-model-backend": "1.4.28",
+    "@milaboratories/ts-helpers": "1.8.6"
   },
   "devDependencies": {
     "@types/node": "~24.5.2",
@@ -26,8 +26,8 @@
     "typescript": "7.0.2",
     "vitest": "^4.1.3",
     "@milaboratories/build-configs": "2.0.2",
-    "@milaboratories/ts-configs": "1.4.0",
-    "@milaboratories/ts-builder": "1.7.2"
+    "@milaboratories/ts-builder": "1.7.2",
+    "@milaboratories/ts-configs": "1.4.0"
   },
   "engines": {
     "node": ">=22"

package/src/compiler/imports.test.ts

@@ -99,18 +99,92 @@ doSomething := func() {
     expect(unusedAliases(src)).toEqual([]);
   });
 
-  test("a module the code only passes around counts as unused", () => {
-    // We ask for the dot on purpose: keeping an import too long costs
-    // nothing, dropping one the source needs breaks the build.
+  test("a lib called directly counts as used", () => {
+    const src = `calculateExportSpecs := import(":export-specs")
+
+doSomething := func(x) {
+	return calculateExportSpecs(x)
+}
+`;
+    expect(unusedAliases(src)).toEqual([]);
+  });
+
+  test("a module passed as a value counts as used", () => {
     const src = `text := import("text")
 
 doSomething := func() {
 	return apply(text)
 }
+`;
+    expect(unusedAliases(src)).toEqual([]);
+  });
+
+  test("an alias used only as an array element or a map value counts as used", () => {
+    const src = `ll := import(":ll")
+sets := import(":sets")
+
+doSomething := func() {
+	return { handlers: [ll], fallback: sets }
+}
+`;
+    expect(unusedAliases(src)).toEqual([]);
+  });
+
+  test("an alias returned bare counts as used", () => {
+    const src = `maps := import(":maps")
+
+doSomething := func() {
+	return maps
+}
+`;
+    expect(unusedAliases(src)).toEqual([]);
+  });
+
+  test("the import line itself is not a usage", () => {
+    const src = `calculateExportSpecs := import(":export-specs")
+
+doSomething := func(x) {
+	return x
+}
+`;
+    expect(unusedAliases(src)).toEqual(["calculateExportSpecs"]);
+  });
+
+  test("a declaration that shadows the alias is not a usage", () => {
+    // Only the declaration is excluded. A read of the shadowing local is a bare
+    // reference, and that does count. Real code therefore keeps the import.
+    const src = `text := import("text")
+
+doSomething := func() {
+	text := "local"
+	return 1
+}
 `;
     expect(unusedAliases(src)).toEqual(["text"]);
   });
 
+  test("the alias as a member of another value still counts as used", () => {
+    // The check is wide on purpose. It never reports an import that the
+    // previous predicate kept.
+    const src = `text := import("text")
+
+doSomething := func(opts) {
+	return opts.text
+}
+`;
+    expect(unusedAliases(src)).toEqual([]);
+  });
+
+  test("a longer name that starts with the alias is not a usage", () => {
+    const src = `ll := import(":ll")
+
+doSomething := func() {
+	return llExtra(1)
+}
+`;
+    expect(unusedAliases(src)).toEqual(["ll"]);
+  });
+
   test("reports the line of each import", () => {
     const src = `ll := import(":ll")
 sets := import(":sets")

package/src/compiler/imports.ts

@@ -32,14 +32,26 @@ function escapeForRegExp(s: string): string {
 /**
  * Find imports the source does not use.
  *
- * An import is used when its alias appears with a dot somewhere else in the
- * code: 'text.split(...)'. A module passed around as a value, say
- * 'myFunc(text)', counts as unused. This is deliberate: the cost of keeping an
- * import the source no longer needs is nothing, while the cost of dropping one
- * it does need is a broken build.
+ * An import counts as used when its alias appears elsewhere in the code as a
+ * name of its own. Three shapes count:
  *
- * Throws when the source does not parse, with the same line context the
- * compiler reports.
+ * - dereferenced: 'text.split(x)'
+ * - called: 'doIt(x)', for a lib that exports a bare function
+ * - passed as a value: 'myFunc(text)'
+ *
+ * Two shapes do not count. A longer name that ends with the alias ('xtext') is
+ * a different name. A declaration that shadows the alias ('text := ...') binds
+ * the name. It does not read the import.
+ *
+ * Every other occurrence counts. This includes a member of another value
+ * ('opts.text') and text inside a string literal ('"a text file"'). The check
+ * is wide on purpose. An import that the source no longer needs costs nothing.
+ * A dropped import that the source needs breaks the build. The predicate must
+ * stay wider than every earlier predicate. A release then reports fewer unused
+ * imports, and never more.
+ *
+ * Throws when the source does not parse. The error carries the same line
+ * context that the compiler reports.
  */
 export function findUnusedImports(
   logger: MiLogger,
@@ -75,7 +87,7 @@ export function findUnusedImports(
   }
 
   return imports.filter((im) => {
-    const usageRE = new RegExp(`\\b${escapeForRegExp(im.alias)}\\s*\\.`);
+    const usageRE = new RegExp(`(?<!\\w)${escapeForRegExp(im.alias)}\\b(?!\\s*:=)`);
     return !codeLines.some((code, lineNo) => lineNo !== im.lineNo && usageRE.test(code));
   });
 }