ember-repl 2.0.63 → 3.0.0-beta.0

package/README.md

@@ -28,6 +28,37 @@ your app's initial time-to-interactive/etc stats.
 ember install ember-repl
 ```
 
+## Setup
+
+This library uses babel, which does some goofy things in the browser.
+You'll need to define a global `process` and `Buffer` somewhere in your app.
+
+For example:
+```js 
+// app/app.js
+
+// @babel/traverse (from babel-plugin-ember-template-imports)
+// accesses process.....
+// maybe one day we can have a browser-only verison?
+// But they aren't used.... so.. that's fun.
+Object.assign(window, {
+  process: { env: {} },
+  Buffer: {},
+});
+
+```
+
+Additionally, because the ember-template-compiler is presently "goofy" in `ember-source`, we must do this in `ember-cli-build.js`:
+
+```js 
+const app = new EmberApp(defaults, {
+  // ...
+});
+app.import('vendor/ember/ember-template-compiler.js');
+
+// ...
+```
+
 ## Usage
 
 **`compileJS`**

package/addon-main.cjs

@@ -0,0 +1,5 @@
+'use strict';
+
+const { addonV1Shim } = require('@embroider/addon-shim');
+
+module.exports = addonV1Shim(__dirname);

package/dist/browser/cjs/eval.d.ts

@@ -0,0 +1,10 @@
+import { ExtraModules } from "../types.js";
+import Component from '@glimmer/component';
+declare function evalSnippet(compiled: string, extraModules?: ExtraModules): {
+    default: Component;
+    services?: {
+        [key: string]: unknown;
+    };
+};
+export { evalSnippet };
+//# sourceMappingURL=browser/cjs/eval.d.ts.map

package/dist/browser/cjs/eval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser/cjs/eval.d.ts","sourceRoot":"","sources":["../src/browser/cjs/eval.ts"],"names":[],"mappings":"AAGA,OAAO,gBAAqB,oBAAiB;AAC7C,OAAO,SAAc,MAAM,oBAAoB,CAAC;AAEhD,iBAAgB,WAAW,CACzB,QAAQ,EAAE,MAAM,EAChB,YAAY,GAAE,YAAiB,GAC9B;IACD,OAAO,EAAE,SAAS,CAAC;IACnB,QAAQ,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;CACvC,CAmBA"}

package/dist/browser/cjs/eval.js

@@ -0,0 +1,22 @@
+import { modules } from '../known-modules.js';
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+function evalSnippet(compiled, extraModules = {}) {
+  const exports = {};
+  function require(moduleName) {
+    let preConfigured = modules[moduleName] || extraModules[moduleName];
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return preConfigured || window.require(moduleName);
+  }
+
+  // https://github.com/glimmerjs/glimmer-experimental/blob/master/packages/examples/playground/src/utils/eval-snippet.ts
+  eval(compiled);
+  return Object.assign(exports, {
+    require
+  });
+}
+
+export { evalSnippet };
+//# sourceMappingURL=eval.js.map

package/dist/browser/cjs/eval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"eval.js","sources":["../../../src/browser/cjs/eval.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\nimport { modules } from '../known-modules';\n\nimport type { ExtraModules } from '../types';\nimport type Component from '@glimmer/component';\n\nexport function evalSnippet(\n  compiled: string,\n  extraModules: ExtraModules = {}\n): {\n  default: Component;\n  services?: { [key: string]: unknown };\n} {\n  const exports = {};\n\n  function require(moduleName: keyof typeof modules): unknown {\n    let preConfigured = modules[moduleName] || extraModules[moduleName];\n\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    return preConfigured || window.require(moduleName);\n  }\n\n  // https://github.com/glimmerjs/glimmer-experimental/blob/master/packages/examples/playground/src/utils/eval-snippet.ts\n  eval(compiled);\n\n  return Object.assign(exports, { require }) as {\n    default: Component;\n    services?: { [key: string]: unknown };\n    require: unknown;\n  };\n}\n"],"names":["evalSnippet","compiled","extraModules","exports","require","moduleName","preConfigured","modules","window","eval","Object","assign"],"mappings":";;AAAA;AAMO,SAASA,WAAWA,CACzBC,QAAgB,EAChBC,YAA0B,GAAG,EAAE,EAI/B;EACA,MAAMC,OAAO,GAAG,EAAE,CAAA;EAElB,SAASC,OAAOA,CAACC,UAAgC,EAAW;IAC1D,IAAIC,aAAa,GAAGC,OAAO,CAACF,UAAU,CAAC,IAAIH,YAAY,CAACG,UAAU,CAAC,CAAA;;AAEnE;AACA;AACA,IAAA,OAAOC,aAAa,IAAIE,MAAM,CAACJ,OAAO,CAACC,UAAU,CAAC,CAAA;AACpD,GAAA;;AAEA;EACAI,IAAI,CAACR,QAAQ,CAAC,CAAA;AAEd,EAAA,OAAOS,MAAM,CAACC,MAAM,CAACR,OAAO,EAAE;AAAEC,IAAAA,OAAAA;AAAQ,GAAC,CAAC,CAAA;AAK5C;;;;"}

package/dist/browser/cjs/index.d.ts

@@ -0,0 +1,7 @@
+import { CompileResult, ExtraModules } from "../types.js";
+interface Info {
+    code: string;
+    name: string;
+}
+declare function compileJS(code: string, extraModules?: ExtraModules): Promise<CompileResult>;
+export { Info, compileJS };

package/dist/browser/cjs/index.js

@@ -0,0 +1,43 @@
+import { preprocess, transform } from '../gjs.js';
+import { nameFor } from '../utils.js';
+import { evalSnippet } from './eval.js';
+
+async function compileJS(code, extraModules) {
+  let name = nameFor(code);
+  let component;
+  let error;
+  try {
+    let compiled = await compileGJS({
+      code: code,
+      name
+    });
+    if (!compiled) {
+      throw new Error(`Compiled output is missing`);
+    }
+    component = evalSnippet(compiled, extraModules).default;
+  } catch (e) {
+    error = e;
+  }
+  return {
+    name,
+    component,
+    error
+  };
+}
+async function compileGJS({
+  code: input,
+  name
+}) {
+  let preprocessed = preprocess(input, name);
+  let result = await transform(preprocessed, name);
+  if (!result) {
+    return;
+  }
+  let {
+    code
+  } = result;
+  return code;
+}
+
+export { compileJS };
+//# sourceMappingURL=index.js.map

package/dist/browser/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/browser/cjs/index.ts"],"sourcesContent":["import { preprocess, transform } from '../gjs';\nimport { nameFor } from '../utils';\nimport { evalSnippet } from './eval';\n\nimport type { CompileResult, ExtraModules } from '../types';\nimport type { ComponentLike } from '@glint/template';\n\nexport interface Info {\n  code: string;\n  name: string;\n}\n\nexport async function compileJS(code: string, extraModules?: ExtraModules): Promise<CompileResult> {\n  let name = nameFor(code);\n  let component: undefined | ComponentLike;\n  let error: undefined | Error;\n\n  try {\n    let compiled = await compileGJS({ code: code, name });\n\n    if (!compiled) {\n      throw new Error(`Compiled output is missing`);\n    }\n\n    component = evalSnippet(compiled, extraModules).default as unknown as ComponentLike;\n  } catch (e) {\n    error = e as Error | undefined;\n  }\n\n  return { name, component, error };\n}\n\nasync function compileGJS({ code: input, name }: Info) {\n  let preprocessed = preprocess(input, name);\n  let result = await transform(preprocessed, name);\n\n  if (!result) {\n    return;\n  }\n\n  let { code } = result;\n\n  return code;\n}\n"],"names":["compileJS","code","extraModules","name","nameFor","component","error","compiled","compileGJS","Error","evalSnippet","default","e","input","preprocessed","preprocess","result","transform"],"mappings":";;;;AAYO,eAAeA,SAASA,CAACC,IAAY,EAAEC,YAA2B,EAA0B;AACjG,EAAA,IAAIC,IAAI,GAAGC,OAAO,CAACH,IAAI,CAAC,CAAA;AACxB,EAAA,IAAII,SAAoC,CAAA;AACxC,EAAA,IAAIC,KAAwB,CAAA;EAE5B,IAAI;AACF,IAAA,IAAIC,QAAQ,GAAG,MAAMC,UAAU,CAAC;AAAEP,MAAAA,IAAI,EAAEA,IAAI;AAAEE,MAAAA,IAAAA;AAAK,KAAC,CAAC,CAAA;IAErD,IAAI,CAACI,QAAQ,EAAE;AACb,MAAA,MAAM,IAAIE,KAAK,CAAE,CAAA,0BAAA,CAA2B,CAAC,CAAA;AAC/C,KAAA;IAEAJ,SAAS,GAAGK,WAAW,CAACH,QAAQ,EAAEL,YAAY,CAAC,CAACS,OAAmC,CAAA;GACpF,CAAC,OAAOC,CAAC,EAAE;AACVN,IAAAA,KAAK,GAAGM,CAAsB,CAAA;AAChC,GAAA;EAEA,OAAO;IAAET,IAAI;IAAEE,SAAS;AAAEC,IAAAA,KAAAA;GAAO,CAAA;AACnC,CAAA;AAEA,eAAeE,UAAUA,CAAC;AAAEP,EAAAA,IAAI,EAAEY,KAAK;AAAEV,EAAAA,IAAAA;AAAW,CAAC,EAAE;AACrD,EAAA,IAAIW,YAAY,GAAGC,UAAU,CAACF,KAAK,EAAEV,IAAI,CAAC,CAAA;EAC1C,IAAIa,MAAM,GAAG,MAAMC,SAAS,CAACH,YAAY,EAAEX,IAAI,CAAC,CAAA;EAEhD,IAAI,CAACa,MAAM,EAAE;AACX,IAAA,OAAA;AACF,GAAA;EAEA,IAAI;AAAEf,IAAAA,IAAAA;AAAK,GAAC,GAAGe,MAAM,CAAA;AAErB,EAAA,OAAOf,IAAI,CAAA;AACb;;;;"}

package/dist/browser/esm/index.d.ts

@@ -0,0 +1,8 @@
+import { CompileResult, ExtraModules } from "../types.js";
+interface Info {
+    code: string;
+    name: string;
+}
+declare function compileJS(code: string, extraModules?: ExtraModules): Promise<CompileResult>;
+declare function proxyToSkypack(code: string, extraModules?: ExtraModules): string;
+export { Info, compileJS, proxyToSkypack };

package/dist/browser/esm/index.js

@@ -0,0 +1,67 @@
+import { preprocess, transform } from '../gjs.js';
+import { modules } from '../known-modules.js';
+import { nameFor } from '../utils.js';
+
+async function compileJS(code, extraModules) {
+  let name = nameFor(code);
+  let component;
+  let error;
+  try {
+    let compiled = await compileGJS({
+      code: code,
+      name
+    });
+    if (!compiled) {
+      throw new Error(`Compiled output is missing`);
+    }
+
+    // NOTE: we cannot `eval` ESM
+    compiled = proxyToSkypack(compiled, extraModules);
+    component = await evalSnippet(compiled);
+  } catch (e) {
+    error = e;
+  }
+  return {
+    name,
+    component,
+    error
+  };
+}
+function proxyToSkypack(code, extraModules) {
+  let knownModules = [...Object.keys(extraModules || {}), ...Object.keys(modules)];
+  let origin = location.origin;
+  let result = code.replaceAll(/from ('|")([^"']+)('|")/g, (_, __, modulePath) => {
+    if (knownModules.includes(modulePath)) {
+      return `from '${origin}/${modulePath}'`;
+    }
+    return `from 'https://cdn.skypack.dev/${modulePath}'`;
+  });
+  return result;
+}
+async function evalSnippet(code) {
+  let encodedJs = encodeURIComponent(code);
+  let result = await import( /* webpackIgnore: true */`data:text/javascript;charset=utf-8,${encodedJs}`);
+  if (!result.default) {
+    throw new Error(`Expected module to have a default export, found ${Object.keys(result)}`);
+  }
+  return result;
+}
+async function compileGJS({
+  code: input,
+  name
+}) {
+  let preprocessed = preprocess(input, name);
+  let result = await transform(preprocessed, name, {
+    modules: false
+  });
+  if (!result) {
+    return;
+  }
+  let {
+    code
+  } = result;
+  return code;
+}
+
+export { compileJS, proxyToSkypack };
+//# sourceMappingURL=index.js.map

package/dist/browser/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/browser/esm/index.ts"],"sourcesContent":["import { preprocess, transform } from '../gjs';\nimport { modules } from '../known-modules';\nimport { nameFor } from '../utils';\n\nimport type { CompileResult, ExtraModules } from '../types';\nimport type Component from '@glimmer/component';\nimport type { ComponentLike } from '@glint/template';\n\nexport interface Info {\n  code: string;\n  name: string;\n}\n\nexport async function compileJS(code: string, extraModules?: ExtraModules): Promise<CompileResult> {\n  let name = nameFor(code);\n  let component: undefined | ComponentLike;\n  let error: undefined | Error;\n\n  try {\n    let compiled = await compileGJS({ code: code, name });\n\n    if (!compiled) {\n      throw new Error(`Compiled output is missing`);\n    }\n\n    // NOTE: we cannot `eval` ESM\n    compiled = proxyToSkypack(compiled, extraModules);\n    component = (await evalSnippet(compiled)) as unknown as ComponentLike;\n  } catch (e) {\n    error = e as Error | undefined;\n  }\n\n  return { name, component, error };\n}\n\nexport function proxyToSkypack(code: string, extraModules?: ExtraModules) {\n  let knownModules = [...Object.keys(extraModules || {}), ...Object.keys(modules)];\n  let origin = location.origin;\n\n  let result = code.replaceAll(/from ('|\")([^\"']+)('|\")/g, (_, __, modulePath) => {\n    if (knownModules.includes(modulePath)) {\n      return `from '${origin}/${modulePath}'`;\n    }\n\n    return `from 'https://cdn.skypack.dev/${modulePath}'`;\n  });\n\n  return result;\n}\n\nasync function evalSnippet(code: string) {\n  let encodedJs = encodeURIComponent(code);\n  let result = await import(\n    /* webpackIgnore: true */ `data:text/javascript;charset=utf-8,${encodedJs}`\n  );\n\n  if (!result.default) {\n    throw new Error(`Expected module to have a default export, found ${Object.keys(result)}`);\n  }\n\n  return result as {\n    default: Component;\n    services?: { [key: string]: unknown };\n  };\n}\n\nasync function compileGJS({ code: input, name }: Info) {\n  let preprocessed = preprocess(input, name);\n  let result = await transform(preprocessed, name, {\n    modules: false,\n  });\n\n  if (!result) {\n    return;\n  }\n\n  let { code } = result;\n\n  return code;\n}\n"],"names":["compileJS","code","extraModules","name","nameFor","component","error","compiled","compileGJS","Error","proxyToSkypack","evalSnippet","e","knownModules","Object","keys","modules","origin","location","result","replaceAll","_","__","modulePath","includes","encodedJs","encodeURIComponent","default","input","preprocessed","preprocess","transform"],"mappings":";;;;AAaO,eAAeA,SAASA,CAACC,IAAY,EAAEC,YAA2B,EAA0B;AACjG,EAAA,IAAIC,IAAI,GAAGC,OAAO,CAACH,IAAI,CAAC,CAAA;AACxB,EAAA,IAAII,SAAoC,CAAA;AACxC,EAAA,IAAIC,KAAwB,CAAA;EAE5B,IAAI;AACF,IAAA,IAAIC,QAAQ,GAAG,MAAMC,UAAU,CAAC;AAAEP,MAAAA,IAAI,EAAEA,IAAI;AAAEE,MAAAA,IAAAA;AAAK,KAAC,CAAC,CAAA;IAErD,IAAI,CAACI,QAAQ,EAAE;AACb,MAAA,MAAM,IAAIE,KAAK,CAAE,CAAA,0BAAA,CAA2B,CAAC,CAAA;AAC/C,KAAA;;AAEA;AACAF,IAAAA,QAAQ,GAAGG,cAAc,CAACH,QAAQ,EAAEL,YAAY,CAAC,CAAA;AACjDG,IAAAA,SAAS,GAAI,MAAMM,WAAW,CAACJ,QAAQ,CAA8B,CAAA;GACtE,CAAC,OAAOK,CAAC,EAAE;AACVN,IAAAA,KAAK,GAAGM,CAAsB,CAAA;AAChC,GAAA;EAEA,OAAO;IAAET,IAAI;IAAEE,SAAS;AAAEC,IAAAA,KAAAA;GAAO,CAAA;AACnC,CAAA;AAEO,SAASI,cAAcA,CAACT,IAAY,EAAEC,YAA2B,EAAE;EACxE,IAAIW,YAAY,GAAG,CAAC,GAAGC,MAAM,CAACC,IAAI,CAACb,YAAY,IAAI,EAAE,CAAC,EAAE,GAAGY,MAAM,CAACC,IAAI,CAACC,OAAO,CAAC,CAAC,CAAA;AAChF,EAAA,IAAIC,MAAM,GAAGC,QAAQ,CAACD,MAAM,CAAA;AAE5B,EAAA,IAAIE,MAAM,GAAGlB,IAAI,CAACmB,UAAU,CAAC,0BAA0B,EAAE,CAACC,CAAC,EAAEC,EAAE,EAAEC,UAAU,KAAK;AAC9E,IAAA,IAAIV,YAAY,CAACW,QAAQ,CAACD,UAAU,CAAC,EAAE;AACrC,MAAA,OAAQ,CAAQN,MAAAA,EAAAA,MAAO,CAAGM,CAAAA,EAAAA,UAAW,CAAE,CAAA,CAAA,CAAA;AACzC,KAAA;IAEA,OAAQ,CAAA,8BAAA,EAAgCA,UAAW,CAAE,CAAA,CAAA,CAAA;AACvD,GAAC,CAAC,CAAA;AAEF,EAAA,OAAOJ,MAAM,CAAA;AACf,CAAA;AAEA,eAAeR,WAAWA,CAACV,IAAY,EAAE;AACvC,EAAA,IAAIwB,SAAS,GAAGC,kBAAkB,CAACzB,IAAI,CAAC,CAAA;EACxC,IAAIkB,MAAM,GAAG,MAAM,iCACU,CAAA,mCAAA,EAAqCM,SAAU,CAAA,CAC5E,CAAC,CAAA;AAED,EAAA,IAAI,CAACN,MAAM,CAACQ,OAAO,EAAE;IACnB,MAAM,IAAIlB,KAAK,CAAE,CAAkDK,gDAAAA,EAAAA,MAAM,CAACC,IAAI,CAACI,MAAM,CAAE,CAAA,CAAC,CAAC,CAAA;AAC3F,GAAA;AAEA,EAAA,OAAOA,MAAM,CAAA;AAIf,CAAA;AAEA,eAAeX,UAAUA,CAAC;AAAEP,EAAAA,IAAI,EAAE2B,KAAK;AAAEzB,EAAAA,IAAAA;AAAW,CAAC,EAAE;AACrD,EAAA,IAAI0B,YAAY,GAAGC,UAAU,CAACF,KAAK,EAAEzB,IAAI,CAAC,CAAA;EAC1C,IAAIgB,MAAM,GAAG,MAAMY,SAAS,CAACF,YAAY,EAAE1B,IAAI,EAAE;AAC/Ca,IAAAA,OAAO,EAAE,KAAA;AACX,GAAC,CAAC,CAAA;EAEF,IAAI,CAACG,MAAM,EAAE;AACX,IAAA,OAAA;AACF,GAAA;EAEA,IAAI;AAAElB,IAAAA,IAAAA;AAAK,GAAC,GAAGkB,MAAM,CAAA;AAErB,EAAA,OAAOlB,IAAI,CAAA;AACb;;;;"}

package/dist/browser/eti/babel-plugin.d.ts

@@ -0,0 +1,54 @@
+/**
+ * This Babel plugin takes parseable code emitted by the string-based
+ * preprocessor plugin in this package and converts it into calls to
+ * the standardized `precompileTemplate` macro from `@ember/template-compilation`.
+ *
+ * Its goal is to convert code like this:
+ *
+ * ```js
+ * import { hbs } from 'ember-template-imports';
+ *
+ * const A = hbs(`A`, {...});
+ * const B = [__GLIMMER_TEMPLATE(`B`, {...})];
+ * class C {
+ *   template = hbs(`C`, {...});
+ * }
+ *
+ * [__GLIMMER_TEMPLATE(`default`, {...})];
+ *
+ * class D {
+ *   [__GLIMMER_TEMPLATE(`D`, {...})]
+ * }
+ * ```
+ *
+ * Into this:
+ *
+ * ```js
+ * import { precompileTemplate } from '@ember/template-compilation';
+ * import { setComponentTemplate } from '@ember/component';
+ * import templateOnlyComponent from '@ember/component/template-only';
+ *
+ * const A = setComponentTemplate(
+ *   precompileTemplate(`A`, {...}),
+ *   templateOnlyComponent('this-module.js', 'A')
+ * );
+ * const B = setComponentTemplate(
+ *   precompileTemplate(`B`, {...}),
+ *   templateOnlyComponent('this-module.js', 'B')
+ * );
+ * class C {}
+ * setComponentTemplate(precompileTemplate(`C`, {...}), C);
+ *
+ * export default setComponentTemplate(
+ *   precompileTemplate(`default`, {...}),
+ *   templateOnlyComponent('this-module.js', '_thisModule')
+ * );
+ *
+ * class D {}
+ * setComponentTemplate(precompileTemplate(`D`, {...}), D);
+ * ```
+ */
+declare function babelPluginFunc(babel: any): {
+    visitor: any;
+};
+export { babelPluginFunc as default };

package/dist/browser/eti/babel-plugin.js

@@ -0,0 +1,95 @@
+import { ImportUtil } from 'babel-import-util';
+import { transformTemplateTag } from './template-tag-transform.js';
+import { isTemplateTag } from './util.js';
+
+/**
+ * This Babel plugin takes parseable code emitted by the string-based
+ * preprocessor plugin in this package and converts it into calls to
+ * the standardized `precompileTemplate` macro from `@ember/template-compilation`.
+ *
+ * Its goal is to convert code like this:
+ *
+ * ```js
+ * import { hbs } from 'ember-template-imports';
+ *
+ * const A = hbs(`A`, {...});
+ * const B = [__GLIMMER_TEMPLATE(`B`, {...})];
+ * class C {
+ *   template = hbs(`C`, {...});
+ * }
+ *
+ * [__GLIMMER_TEMPLATE(`default`, {...})];
+ *
+ * class D {
+ *   [__GLIMMER_TEMPLATE(`D`, {...})]
+ * }
+ * ```
+ *
+ * Into this:
+ *
+ * ```js
+ * import { precompileTemplate } from '@ember/template-compilation';
+ * import { setComponentTemplate } from '@ember/component';
+ * import templateOnlyComponent from '@ember/component/template-only';
+ *
+ * const A = setComponentTemplate(
+ *   precompileTemplate(`A`, {...}),
+ *   templateOnlyComponent('this-module.js', 'A')
+ * );
+ * const B = setComponentTemplate(
+ *   precompileTemplate(`B`, {...}),
+ *   templateOnlyComponent('this-module.js', 'B')
+ * );
+ * class C {}
+ * setComponentTemplate(precompileTemplate(`C`, {...}), C);
+ *
+ * export default setComponentTemplate(
+ *   precompileTemplate(`default`, {...}),
+ *   templateOnlyComponent('this-module.js', '_thisModule')
+ * );
+ *
+ * class D {}
+ * setComponentTemplate(precompileTemplate(`D`, {...}), D);
+ * ```
+ */
+function babelPluginIntermediateGJS (babel) {
+  let t = babel.types;
+  let visitor = {
+    Program: {
+      enter(path, state) {
+        state.importUtil = new ImportUtil(t, path);
+      }
+    },
+    // Process class bodies before things like class properties get transformed
+    // into imperative constructor code that we can't recognize. Taken directly
+    // from babel-plugin-htmlbars-inline-precompile https://git.io/JMi1G
+    Class(path, state) {
+      let bodyPath = path.get('body.body');
+      if (!Array.isArray(bodyPath)) return;
+      bodyPath.forEach(path => {
+        if (path.type !== 'ClassProperty') return;
+        let keyPath = path.get('key');
+        let valuePath = path.get('value');
+        if (Array.isArray(keyPath)) return;
+        if (keyPath && visitor[keyPath.type]) {
+          visitor[keyPath.type](keyPath, state);
+        }
+        if (Array.isArray(valuePath)) return;
+        if (valuePath && visitor[valuePath.type]) {
+          visitor[valuePath.type](valuePath, state);
+        }
+      });
+    },
+    CallExpression(path, state) {
+      if (isTemplateTag(path)) {
+        transformTemplateTag(t, path, state);
+      }
+    }
+  };
+  return {
+    visitor
+  };
+}
+
+export { babelPluginIntermediateGJS as default };
+//# sourceMappingURL=babel-plugin.js.map

package/dist/browser/eti/babel-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"babel-plugin.js","sources":["../../../src/browser/eti/babel-plugin.ts"],"sourcesContent":["import { ImportUtil } from 'babel-import-util';\n\nimport { transformTemplateTag } from './template-tag-transform';\nimport * as util from './util';\n\nimport type { NodePath } from '@babel/traverse';\nimport type { CallExpression, Class, Program } from '@babel/types';\n\n/**\n * This Babel plugin takes parseable code emitted by the string-based\n * preprocessor plugin in this package and converts it into calls to\n * the standardized `precompileTemplate` macro from `@ember/template-compilation`.\n *\n * Its goal is to convert code like this:\n *\n * ```js\n * import { hbs } from 'ember-template-imports';\n *\n * const A = hbs(`A`, {...});\n * const B = [__GLIMMER_TEMPLATE(`B`, {...})];\n * class C {\n *   template = hbs(`C`, {...});\n * }\n *\n * [__GLIMMER_TEMPLATE(`default`, {...})];\n *\n * class D {\n *   [__GLIMMER_TEMPLATE(`D`, {...})]\n * }\n * ```\n *\n * Into this:\n *\n * ```js\n * import { precompileTemplate } from '@ember/template-compilation';\n * import { setComponentTemplate } from '@ember/component';\n * import templateOnlyComponent from '@ember/component/template-only';\n *\n * const A = setComponentTemplate(\n *   precompileTemplate(`A`, {...}),\n *   templateOnlyComponent('this-module.js', 'A')\n * );\n * const B = setComponentTemplate(\n *   precompileTemplate(`B`, {...}),\n *   templateOnlyComponent('this-module.js', 'B')\n * );\n * class C {}\n * setComponentTemplate(precompileTemplate(`C`, {...}), C);\n *\n * export default setComponentTemplate(\n *   precompileTemplate(`default`, {...}),\n *   templateOnlyComponent('this-module.js', '_thisModule')\n * );\n *\n * class D {}\n * setComponentTemplate(precompileTemplate(`D`, {...}), D);\n * ```\n */\nexport default function (babel: any) {\n  let t = babel.types;\n\n  let visitor: any = {\n    Program: {\n      enter(path: NodePath<Program>, state: any) {\n        state.importUtil = new ImportUtil(t, path);\n      },\n    },\n\n    // Process class bodies before things like class properties get transformed\n    // into imperative constructor code that we can't recognize. Taken directly\n    // from babel-plugin-htmlbars-inline-precompile https://git.io/JMi1G\n    Class(path: NodePath<Class>, state: any) {\n      let bodyPath = path.get('body.body');\n\n      if (!Array.isArray(bodyPath)) return;\n\n      bodyPath.forEach((path) => {\n        if (path.type !== 'ClassProperty') return;\n\n        let keyPath = path.get('key');\n        let valuePath = path.get('value');\n\n        if (Array.isArray(keyPath)) return;\n\n        if (keyPath && visitor[keyPath.type]) {\n          visitor[keyPath.type](keyPath, state);\n        }\n\n        if (Array.isArray(valuePath)) return;\n\n        if (valuePath && visitor[valuePath.type]) {\n          visitor[valuePath.type](valuePath, state);\n        }\n      });\n    },\n\n    CallExpression(path: NodePath<CallExpression>, state: any) {\n      if (util.isTemplateTag(path)) {\n        transformTemplateTag(t, path, state);\n      }\n    },\n  };\n\n  return { visitor };\n}\n"],"names":["babel","t","types","visitor","Program","enter","path","state","importUtil","ImportUtil","Class","bodyPath","get","Array","isArray","forEach","type","keyPath","valuePath","CallExpression","util","transformTemplateTag"],"mappings":";;;;AAQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACe,mCAAA,EAAUA,KAAU,EAAE;AACnC,EAAA,IAAIC,CAAC,GAAGD,KAAK,CAACE,KAAK,CAAA;AAEnB,EAAA,IAAIC,OAAY,GAAG;AACjBC,IAAAA,OAAO,EAAE;AACPC,MAAAA,KAAKA,CAACC,IAAuB,EAAEC,KAAU,EAAE;QACzCA,KAAK,CAACC,UAAU,GAAG,IAAIC,UAAU,CAACR,CAAC,EAAEK,IAAI,CAAC,CAAA;AAC5C,OAAA;KACD;AAED;AACA;AACA;AACAI,IAAAA,KAAKA,CAACJ,IAAqB,EAAEC,KAAU,EAAE;AACvC,MAAA,IAAII,QAAQ,GAAGL,IAAI,CAACM,GAAG,CAAC,WAAW,CAAC,CAAA;AAEpC,MAAA,IAAI,CAACC,KAAK,CAACC,OAAO,CAACH,QAAQ,CAAC,EAAE,OAAA;AAE9BA,MAAAA,QAAQ,CAACI,OAAO,CAAET,IAAI,IAAK;AACzB,QAAA,IAAIA,IAAI,CAACU,IAAI,KAAK,eAAe,EAAE,OAAA;AAEnC,QAAA,IAAIC,OAAO,GAAGX,IAAI,CAACM,GAAG,CAAC,KAAK,CAAC,CAAA;AAC7B,QAAA,IAAIM,SAAS,GAAGZ,IAAI,CAACM,GAAG,CAAC,OAAO,CAAC,CAAA;AAEjC,QAAA,IAAIC,KAAK,CAACC,OAAO,CAACG,OAAO,CAAC,EAAE,OAAA;QAE5B,IAAIA,OAAO,IAAId,OAAO,CAACc,OAAO,CAACD,IAAI,CAAC,EAAE;UACpCb,OAAO,CAACc,OAAO,CAACD,IAAI,CAAC,CAACC,OAAO,EAAEV,KAAK,CAAC,CAAA;AACvC,SAAA;AAEA,QAAA,IAAIM,KAAK,CAACC,OAAO,CAACI,SAAS,CAAC,EAAE,OAAA;QAE9B,IAAIA,SAAS,IAAIf,OAAO,CAACe,SAAS,CAACF,IAAI,CAAC,EAAE;UACxCb,OAAO,CAACe,SAAS,CAACF,IAAI,CAAC,CAACE,SAAS,EAAEX,KAAK,CAAC,CAAA;AAC3C,SAAA;AACF,OAAC,CAAC,CAAA;KACH;AAEDY,IAAAA,cAAcA,CAACb,IAA8B,EAAEC,KAAU,EAAE;AACzD,MAAA,IAAIa,aAAkB,CAACd,IAAI,CAAC,EAAE;AAC5Be,QAAAA,oBAAoB,CAACpB,CAAC,EAAEK,IAAI,EAAEC,KAAK,CAAC,CAAA;AACtC,OAAA;AACF,KAAA;GACD,CAAA;EAED,OAAO;AAAEJ,IAAAA,OAAAA;GAAS,CAAA;AACpB;;;;"}

package/dist/browser/eti/debug.d.ts

@@ -0,0 +1,2 @@
+declare function expect<T>(value: T | null | undefined, message: string): T;
+export { expect };

package/dist/browser/eti/debug.js

@@ -0,0 +1,9 @@
+function expect(value, message) {
+  if (value === undefined || value === null) {
+    throw new Error(`LIBRARY BUG: ${message}`);
+  }
+  return value;
+}
+
+export { expect };
+//# sourceMappingURL=debug.js.map

package/dist/browser/eti/debug.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.js","sources":["../../../src/browser/eti/debug.ts"],"sourcesContent":["export function expect<T>(value: T | null | undefined, message: string): T {\n  if (value === undefined || value === null) {\n    throw new Error(`LIBRARY BUG: ${message}`);\n  }\n\n  return value;\n}\n"],"names":["expect","value","message","undefined","Error"],"mappings":"AAAO,SAASA,MAAMA,CAAIC,KAA2B,EAAEC,OAAe,EAAK;AACzE,EAAA,IAAID,KAAK,KAAKE,SAAS,IAAIF,KAAK,KAAK,IAAI,EAAE;AACzC,IAAA,MAAM,IAAIG,KAAK,CAAE,CAAeF,aAAAA,EAAAA,OAAQ,EAAC,CAAC,CAAA;AAC5C,GAAA;AAEA,EAAA,OAAOD,KAAK,CAAA;AACd;;;;"}

package/dist/browser/eti/parse-templates.d.ts

@@ -0,0 +1,56 @@
+type TemplateMatch = TemplateTagMatch;
+interface TemplateTagMatch {
+    type: 'template-tag';
+    tagName: string;
+    start: RegExpMatchArray;
+    end: RegExpMatchArray;
+    contents: string;
+}
+/**
+ * Represents a static import of a template literal.
+ */
+interface StaticImportConfig {
+    /**
+     * The path to the package from which we want to import the template literal
+     * (e.g.: 'ember-cli-htmlbars')
+     */
+    importPath: string;
+    /**
+     * The name of the template literal (e.g.: 'hbs') or 'default' if this package
+     * exports a default function
+     */
+    importIdentifier: string;
+}
+/**
+ * The input options to instruct parseTemplates on how to parse the input.
+ *
+ * @param templateTag
+ */
+interface ParseTemplatesOptions {
+    /** Tag to use, if parsing template tags is enabled. */
+    templateTag?: string;
+}
+declare const DEFAULT_PARSE_TEMPLATES_OPTIONS: {
+    templateTag: string;
+};
+/**
+ * Parses a template to find all possible valid matches for an embedded template.
+ * Supported syntaxes are template literals:
+ *
+ *   hbs`Hello, world!`
+ *
+ * And template tags
+ *
+ *   <template></template>
+ *
+ * The parser excludes any values found within strings recursively, and also
+ * excludes any string literals with dynamic segments (e.g `${}`) since these
+ * cannot be valid templates.
+ *
+ * @param template The template to parse
+ * @param relativePath Relative file path for the template (for errors)
+ * @param options optional configuration options for how to parse templates
+ * @returns
+ */
+declare function parseTemplates(template: string, relativePath: string, options?: ParseTemplatesOptions): TemplateMatch[];
+export { TemplateMatch, TemplateTagMatch, StaticImportConfig, ParseTemplatesOptions, DEFAULT_PARSE_TEMPLATES_OPTIONS, parseTemplates };

package/dist/browser/eti/parse-templates.js

@@ -0,0 +1,181 @@
+import { expect } from './debug.js';
+import { TEMPLATE_TAG_NAME } from './util.js';
+
+/**
+ * Represents a static import of a template literal.
+ */
+
+/**
+ * The input options to instruct parseTemplates on how to parse the input.
+ *
+ * @param templateTag
+ */
+
+const escapeChar = '\\';
+const stringDelimiter = /['"]/;
+const singleLineCommentStart = /\/\//;
+const newLine = /\n/;
+const multiLineCommentStart = /\/\*/;
+const multiLineCommentEnd = /\*\//;
+const templateLiteralStart = /([$a-zA-Z_][0-9a-zA-Z_$]*)?`/;
+const templateLiteralEnd = /`/;
+const dynamicSegmentStart = /\${/;
+const blockStart = /{/;
+const dynamicSegmentEnd = /}/;
+function isEscaped(template, _offset) {
+  let offset = expect(_offset, 'Expected an index to check escaping');
+  let count = 0;
+  while (template[offset - 1] === escapeChar) {
+    count++;
+    offset--;
+  }
+  return count % 2 === 1;
+}
+const DEFAULT_PARSE_TEMPLATES_OPTIONS = {
+  templateTag: TEMPLATE_TAG_NAME
+};
+
+/**
+ * Parses a template to find all possible valid matches for an embedded template.
+ * Supported syntaxes are template literals:
+ *
+ *   hbs`Hello, world!`
+ *
+ * And template tags
+ *
+ *   <template></template>
+ *
+ * The parser excludes any values found within strings recursively, and also
+ * excludes any string literals with dynamic segments (e.g `${}`) since these
+ * cannot be valid templates.
+ *
+ * @param template The template to parse
+ * @param relativePath Relative file path for the template (for errors)
+ * @param options optional configuration options for how to parse templates
+ * @returns
+ */
+function parseTemplates(template, relativePath, options = DEFAULT_PARSE_TEMPLATES_OPTIONS) {
+  const results = [];
+  const templateTag = options?.templateTag;
+  const templateTagStart = new RegExp(`<${templateTag}[^<]*>`);
+  const templateTagEnd = new RegExp(`</${templateTag}>`);
+  const argumentsMatchRegex = new RegExp(`<${templateTag}[^<]*\\S[^<]*>`);
+  const allTokens = new RegExp([singleLineCommentStart.source, newLine.source, multiLineCommentStart.source, multiLineCommentEnd.source, stringDelimiter.source, templateLiteralStart.source, templateLiteralEnd.source, dynamicSegmentStart.source, dynamicSegmentEnd.source, blockStart.source, templateTagStart.source, templateTagEnd.source].join('|'), 'g');
+  const tokens = Array.from(template.matchAll(allTokens));
+  while (tokens.length > 0) {
+    const currentToken = tokens.shift(); // eslint-disable-line @typescript-eslint/no-non-null-assertion
+
+    parseToken(results, template, currentToken, tokens, true);
+  }
+
+  /**
+   * Parse the current token. If top level, then template tags can be parsed.
+   * Else, we are nested within a dynamic segment, which is currently unsupported.
+   */
+  function parseToken(results, template, token, tokens, isTopLevel = false) {
+    if (token[0].match(multiLineCommentStart)) {
+      parseMultiLineComment(results, template, token, tokens);
+    } else if (token[0].match(singleLineCommentStart)) {
+      parseSingleLineComment(results, template, token, tokens);
+    } else if (token[0].match(templateLiteralStart)) {
+      parseTemplateLiteral(template, tokens);
+    } else if (isTopLevel && templateTag !== undefined && templateTagStart && token[0].match(templateTagStart)) {
+      parseTemplateTag(results, template, token, tokens, templateTag);
+    } else if (token[0].match(stringDelimiter)) {
+      parseString(results, template, token, tokens);
+    }
+  }
+
+  /**
+   * Parse a template literal. If a dynamic segment is found, enters the dynamic
+   * segment and parses it recursively. If no dynamic segments are found and the
+   * literal is top level (e.g. not nested within a dynamic segment) and has a
+   * tag, pushes it into the list of results.
+   */
+  function parseTemplateLiteral(template, tokens) {
+    while (tokens.length > 0) {
+      let currentToken = expect(tokens.shift(), 'expected token');
+      if (isEscaped(template, currentToken.index)) continue;
+      if (currentToken[0].match(templateLiteralEnd)) {
+        return;
+      }
+    }
+  }
+
+  /**
+   * Parse a string. All tokens within a string are ignored
+   * since there are no dynamic segments within these.
+   */
+  function parseString(_results, template, startToken, tokens) {
+    while (tokens.length > 0) {
+      const currentToken = expect(tokens.shift(), 'expected token');
+      if (currentToken[0] === startToken[0] && !isEscaped(template, currentToken.index)) {
+        return;
+      }
+    }
+  }
+
+  /**
+   * Parse a single-line comment. All tokens within a single-line comment are ignored
+   * since there are no dynamic segments within them.
+   */
+  function parseSingleLineComment(_results, _template, _startToken, tokens) {
+    while (tokens.length > 0) {
+      const currentToken = expect(tokens.shift(), 'expected token');
+      if (currentToken[0] === '\n') {
+        return;
+      }
+    }
+  }
+
+  /**
+   * Parse a multi-line comment. All tokens within a multi-line comment are ignored
+   * since there are no dynamic segments within them.
+   */
+  function parseMultiLineComment(_results, _template, _startToken, tokens) {
+    while (tokens.length > 0) {
+      const currentToken = expect(tokens.shift(), 'expected token');
+      if (currentToken[0] === '*/') {
+        return;
+      }
+    }
+  }
+
+  /**
+   * Parses a template tag. Continues parsing until the template tag has closed,
+   * accounting for nested template tags.
+   */
+  function parseTemplateTag(results, _template, startToken, tokens, templateTag) {
+    let stack = 1;
+    if (argumentsMatchRegex && startToken[0].match(argumentsMatchRegex)) {
+      throw new Error(`embedded template preprocessing currently does not support passing arguments, found args in: ${relativePath}`);
+    }
+    while (tokens.length > 0) {
+      const currentToken = expect(tokens.shift(), 'expected token');
+      if (currentToken[0].match(templateTagStart)) {
+        stack++;
+      } else if (currentToken[0].match(templateTagEnd)) {
+        stack--;
+      }
+      if (stack === 0) {
+        let contents = '';
+        if (startToken.index !== undefined) {
+          const templateStart = startToken.index + startToken[0].length;
+          contents = template.slice(templateStart, currentToken.index);
+        }
+        results.push({
+          type: 'template-tag',
+          tagName: templateTag,
+          contents: contents,
+          start: startToken,
+          end: currentToken
+        });
+        return;
+      }
+    }
+  }
+  return results;
+}
+
+export { DEFAULT_PARSE_TEMPLATES_OPTIONS, parseTemplates };
+//# sourceMappingURL=parse-templates.js.map