ember-repl 2.0.63 → 3.0.0-beta.0

package/dist/browser/hbs.js

@@ -0,0 +1,94 @@
+import { setComponentTemplate } from '@ember/component';
+import _TO from '@ember/component/template-only';
+import { array, concat, fn, get, hash } from '@ember/helper';
+import { on } from '@ember/modifier';
+import { createTemplateFactory } from '@ember/template-factory';
+import { importSync } from '@embroider/macros';
+import { nameFor } from './utils.js';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// import { precompileJSON } from '@glimmer/compiler';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+// These things are pre-bundled in the old system.
+// ember-template-compiler defines them in AMD/requirejs
+const {
+  precompileJSON
+} = importSync('@glimmer/compiler');
+const {
+  getTemplateLocals
+} = importSync('@glimmer/syntax');
+
+/**
+ * compile a template with an empty scope
+ * to use components, helpers, etc, you will need to compile with JS
+ *
+ * (templates alone do not have a way to import / define complex structures)
+ */
+function compileHBS(template, options = {}) {
+  let name = nameFor(template);
+  let component;
+  let error;
+  try {
+    component = setComponentTemplate(compileTemplate(template, {
+      moduleName: name,
+      ...options
+    }), _TO(name));
+  } catch (e) {
+    error = e;
+  }
+  return {
+    name,
+    component,
+    error
+  };
+}
+/**
+ * The reason why we can't use precompile directly is because of this:
+ * https://github.com/glimmerjs/glimmer-vm/blob/master/packages/%40glimmer/compiler/lib/compiler.ts#L132
+ *
+ * Support for dynamically compiling templates in strict mode doesn't seem to be fully their yet.
+ * That JSON.stringify (and the lines after) prevent us from easily setting the scope function,
+ * which means that *everything* is undefined.
+ */
+function compileTemplate(source, {
+  moduleName,
+  scope = {}
+}) {
+  let localScope = {
+    array,
+    concat,
+    fn,
+    get,
+    hash,
+    on,
+    ...scope
+  };
+  let locals = getTemplateLocals(source);
+  let options = {
+    strictMode: true,
+    moduleName,
+    locals,
+    isProduction: false,
+    meta: {
+      moduleName
+    }
+  };
+
+  // Copied from @glimmer/compiler/lib/compiler#precompile
+  let [block, usedLocals] = precompileJSON(source, options);
+  let usedScope = usedLocals.map(key => localScope[key]);
+  let blockJSON = JSON.stringify(block);
+  let templateJSONObject = {
+    id: moduleName,
+    block: blockJSON,
+    moduleName: moduleName ?? '(unknown template module)',
+    scope: () => usedScope,
+    isStrictMode: true
+  };
+  let factory = createTemplateFactory(templateJSONObject);
+  return factory;
+}
+
+export { compileHBS };
+//# sourceMappingURL=hbs.js.map

package/dist/browser/hbs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hbs.js","sources":["../../src/browser/hbs.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n// import { precompileJSON } from '@glimmer/compiler';\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nimport { setComponentTemplate } from '@ember/component';\nimport templateOnlyComponent from '@ember/component/template-only';\nimport { array, concat, fn, get, hash } from '@ember/helper';\nimport { on } from '@ember/modifier';\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nimport { createTemplateFactory } from '@ember/template-factory';\nimport { importSync } from '@embroider/macros';\n\nimport { nameFor } from './utils';\n\nimport type { CompileResult } from './types';\nimport type { ComponentLike } from '@glint/template';\n\n// These things are pre-bundled in the old system.\n// ember-template-compiler defines them in AMD/requirejs\nconst { precompileJSON } = importSync('@glimmer/compiler') as any;\nconst { getTemplateLocals } = importSync('@glimmer/syntax') as any;\n\n/**\n * compile a template with an empty scope\n * to use components, helpers, etc, you will need to compile with JS\n *\n * (templates alone do not have a way to import / define complex structures)\n */\nexport function compileHBS(\n  template: string,\n  options: Omit<CompileTemplateOptions, 'moduleName'> = {}\n): CompileResult {\n  let name = nameFor(template);\n  let component: undefined | ComponentLike;\n  let error: undefined | Error;\n\n  try {\n    component = setComponentTemplate(\n      compileTemplate(template, { moduleName: name, ...options }),\n      templateOnlyComponent(name)\n    ) as ComponentLike;\n  } catch (e) {\n    error = e as Error | undefined;\n  }\n\n  return { name, component, error };\n}\n\ninterface CompileTemplateOptions {\n  moduleName: string;\n  scope?: Record<string, unknown>;\n}\n\n/**\n * The reason why we can't use precompile directly is because of this:\n * https://github.com/glimmerjs/glimmer-vm/blob/master/packages/%40glimmer/compiler/lib/compiler.ts#L132\n *\n * Support for dynamically compiling templates in strict mode doesn't seem to be fully their yet.\n * That JSON.stringify (and the lines after) prevent us from easily setting the scope function,\n * which means that *everything* is undefined.\n */\nfunction compileTemplate(source: string, { moduleName, scope = {} }: CompileTemplateOptions) {\n  let localScope = { array, concat, fn, get, hash, on, ...scope } as any;\n  let locals = getTemplateLocals(source);\n\n  let options = {\n    strictMode: true,\n    moduleName,\n    locals,\n    isProduction: false,\n    meta: { moduleName },\n  };\n\n  // Copied from @glimmer/compiler/lib/compiler#precompile\n  let [block, usedLocals] = precompileJSON(source, options);\n\n  let usedScope = usedLocals.map((key: string) => localScope[key]);\n\n  let blockJSON = JSON.stringify(block);\n  let templateJSONObject = {\n    id: moduleName,\n    block: blockJSON,\n    moduleName: moduleName ?? '(unknown template module)',\n    scope: () => usedScope,\n    isStrictMode: true,\n  };\n\n  let factory = createTemplateFactory(templateJSONObject);\n\n  return factory;\n}\n"],"names":["precompileJSON","importSync","getTemplateLocals","compileHBS","template","options","name","nameFor","component","error","setComponentTemplate","compileTemplate","moduleName","templateOnlyComponent","e","source","scope","localScope","array","concat","fn","get","hash","on","locals","strictMode","isProduction","meta","block","usedLocals","usedScope","map","key","blockJSON","JSON","stringify","templateJSONObject","id","isStrictMode","factory","createTemplateFactory"],"mappings":";;;;;;;;AAAA;AACA;AACA;AACA;AAeA;AACA;AACA,MAAM;AAAEA,EAAAA,cAAAA;AAAe,CAAC,GAAGC,UAAU,CAAC,mBAAmB,CAAQ,CAAA;AACjE,MAAM;AAAEC,EAAAA,iBAAAA;AAAkB,CAAC,GAAGD,UAAU,CAAC,iBAAiB,CAAQ,CAAA;;AAElE;AACA;AACA;AACA;AACA;AACA;AACO,SAASE,UAAUA,CACxBC,QAAgB,EAChBC,OAAmD,GAAG,EAAE,EACzC;AACf,EAAA,IAAIC,IAAI,GAAGC,OAAO,CAACH,QAAQ,CAAC,CAAA;AAC5B,EAAA,IAAII,SAAoC,CAAA;AACxC,EAAA,IAAIC,KAAwB,CAAA;EAE5B,IAAI;AACFD,IAAAA,SAAS,GAAGE,oBAAoB,CAC9BC,eAAe,CAACP,QAAQ,EAAE;AAAEQ,MAAAA,UAAU,EAAEN,IAAI;MAAE,GAAGD,OAAAA;AAAQ,KAAC,CAAC,EAC3DQ,GAAqB,CAACP,IAAI,CAC5B,CAAkB,CAAA;GACnB,CAAC,OAAOQ,CAAC,EAAE;AACVL,IAAAA,KAAK,GAAGK,CAAsB,CAAA;AAChC,GAAA;EAEA,OAAO;IAAER,IAAI;IAAEE,SAAS;AAAEC,IAAAA,KAAAA;GAAO,CAAA;AACnC,CAAA;AAOA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAASE,eAAeA,CAACI,MAAc,EAAE;EAAEH,UAAU;AAAEI,EAAAA,KAAK,GAAG,EAAC;AAA0B,CAAC,EAAE;AAC3F,EAAA,IAAIC,UAAU,GAAG;IAAEC,KAAK;IAAEC,MAAM;IAAEC,EAAE;IAAEC,GAAG;IAAEC,IAAI;IAAEC,EAAE;IAAE,GAAGP,KAAAA;GAAc,CAAA;AACtE,EAAA,IAAIQ,MAAM,GAAGtB,iBAAiB,CAACa,MAAM,CAAC,CAAA;AAEtC,EAAA,IAAIV,OAAO,GAAG;AACZoB,IAAAA,UAAU,EAAE,IAAI;IAChBb,UAAU;IACVY,MAAM;AACNE,IAAAA,YAAY,EAAE,KAAK;AACnBC,IAAAA,IAAI,EAAE;AAAEf,MAAAA,UAAAA;AAAW,KAAA;GACpB,CAAA;;AAED;EACA,IAAI,CAACgB,KAAK,EAAEC,UAAU,CAAC,GAAG7B,cAAc,CAACe,MAAM,EAAEV,OAAO,CAAC,CAAA;AAEzD,EAAA,IAAIyB,SAAS,GAAGD,UAAU,CAACE,GAAG,CAAEC,GAAW,IAAKf,UAAU,CAACe,GAAG,CAAC,CAAC,CAAA;AAEhE,EAAA,IAAIC,SAAS,GAAGC,IAAI,CAACC,SAAS,CAACP,KAAK,CAAC,CAAA;AACrC,EAAA,IAAIQ,kBAAkB,GAAG;AACvBC,IAAAA,EAAE,EAAEzB,UAAU;AACdgB,IAAAA,KAAK,EAAEK,SAAS;IAChBrB,UAAU,EAAEA,UAAU,IAAI,2BAA2B;IACrDI,KAAK,EAAEA,MAAMc,SAAS;AACtBQ,IAAAA,YAAY,EAAE,IAAA;GACf,CAAA;AAED,EAAA,IAAIC,OAAO,GAAGC,qBAAqB,CAACJ,kBAAkB,CAAC,CAAA;AAEvD,EAAA,OAAOG,OAAO,CAAA;AAChB;;;;"}

package/dist/browser/index.d.ts

@@ -0,0 +1,5 @@
+export { compileHBS } from "./hbs.js";
+export { compileJS } from "./js.js";
+export { modules as frameworkModules } from "./known-modules.js";
+export { invocationName, invocationOf, nameFor } from "./utils.js";
+export type { CompileResult } from "./types.js";

package/dist/browser/index.js

@@ -0,0 +1,5 @@
+export { compileHBS } from './hbs.js';
+export { compileJS } from './js.js';
+export { modules as frameworkModules } from './known-modules.js';
+export { invocationName, invocationOf, nameFor } from './utils.js';
+//# sourceMappingURL=index.js.map

package/dist/browser/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/{js.d.ts → dist/browser/js.d.ts}

@@ -1,4 +1,4 @@
-import type { ExtraModules, Options } from './types';
+import { CompileResult, ExtraModules, Options } from "./types.js";
 /**
  * @public
  * Transpiles GlimmerJS (*.gjs) formatted text into and evaluates as a JS Module.
@@ -16,8 +16,5 @@ import type { ExtraModules, Options } from './types';
  *  are not provided by extraModules will be searched on npm to see if a package
  *  needs to be downloaded before running the `code` / invoking the component
  */
-export declare function compileJS(code: string, extraModules?: ExtraModules, options?: Options): Promise<{
-    name: string;
-    component: unknown;
-    error: Error | undefined;
-}>;
+declare function compileJS(code: string, extraModules?: ExtraModules, options?: Options): Promise<CompileResult>;
+export { compileJS };

package/dist/browser/js.js

@@ -0,0 +1,38 @@
+import { compileJS as compileJS$2 } from './cjs/index.js';
+import { compileJS as compileJS$1 } from './esm/index.js';
+
+/**
+ * @public
+ * Transpiles GlimmerJS (*.gjs) formatted text into and evaluates as a JS Module.
+ * The returned component can be invoked explicitly in the consuming project.
+ *
+ * SEE: README for example usage
+ *
+ * @param {string} code: the code to be compiled
+ * @param {Object} extraModules: map of import paths to modules. This isn't needed
+ *  for classic ember projects, but for strict static ember projects, extraModules
+ *  will need to be pasesd if compileJS is intended to be used in a styleguide or
+ *  if there are additional modules that could be imported in the passed `code`.
+ *
+ *  Later on, imports that are not present by default (ember/glimmer) or that
+ *  are not provided by extraModules will be searched on npm to see if a package
+ *  needs to be downloaded before running the `code` / invoking the component
+ */
+function compileJS(code, extraModules, options) {
+  if (options?.skypack) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // if (!(window as any).webpackChunkDummy) {
+    //   return {
+    //     component: undefined,
+    //     name: undefined,
+    //     error: `Your environment is using AMD utilities -- using native ESM is not allowed unless the environment is also ESM`,
+    //   };
+    // }
+
+    return compileJS$1(code, extraModules);
+  }
+  return compileJS$2(code, extraModules);
+}
+
+export { compileJS };
+//# sourceMappingURL=js.js.map

package/dist/browser/js.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"js.js","sources":["../../src/browser/js.ts"],"sourcesContent":["import { compileJS as compileAMD } from './cjs';\nimport { compileJS as compileESM } from './esm';\n\nimport type { CompileResult, ExtraModules, Options } from './types';\n\n/**\n * @public\n * Transpiles GlimmerJS (*.gjs) formatted text into and evaluates as a JS Module.\n * The returned component can be invoked explicitly in the consuming project.\n *\n * SEE: README for example usage\n *\n * @param {string} code: the code to be compiled\n * @param {Object} extraModules: map of import paths to modules. This isn't needed\n *  for classic ember projects, but for strict static ember projects, extraModules\n *  will need to be pasesd if compileJS is intended to be used in a styleguide or\n *  if there are additional modules that could be imported in the passed `code`.\n *\n *  Later on, imports that are not present by default (ember/glimmer) or that\n *  are not provided by extraModules will be searched on npm to see if a package\n *  needs to be downloaded before running the `code` / invoking the component\n */\nexport function compileJS(\n  code: string,\n  extraModules?: ExtraModules,\n  options?: Options\n): Promise<CompileResult> {\n  if (options?.skypack) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    // if (!(window as any).webpackChunkDummy) {\n    //   return {\n    //     component: undefined,\n    //     name: undefined,\n    //     error: `Your environment is using AMD utilities -- using native ESM is not allowed unless the environment is also ESM`,\n    //   };\n    // }\n\n    return compileESM(code, extraModules);\n  }\n\n  return compileAMD(code, extraModules);\n}\n"],"names":["compileJS","code","extraModules","options","skypack","compileESM","compileAMD"],"mappings":";;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASA,SAASA,CACvBC,IAAY,EACZC,YAA2B,EAC3BC,OAAiB,EACO;EACxB,IAAIA,OAAO,EAAEC,OAAO,EAAE;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,IAAA,OAAOC,WAAU,CAACJ,IAAI,EAAEC,YAAY,CAAC,CAAA;AACvC,GAAA;AAEA,EAAA,OAAOI,WAAU,CAACL,IAAI,EAAEC,YAAY,CAAC,CAAA;AACvC;;;;"}

package/{known-modules.d.ts → dist/browser/known-modules.d.ts}

@@ -10,20 +10,22 @@ import * as _EmberComponent from '@ember/component';
 import _TO from '@ember/component/template-only';
 import * as _debug from '@ember/debug';
 import * as _destroyable from '@ember/destroyable';
+import * as _helpers from '@ember/helper';
+import * as _modifier from '@ember/modifier';
 import * as _object from '@ember/object';
 import * as _runloop from '@ember/runloop';
 import * as _service from '@ember/service';
 import * as _string from '@ember/string';
 import * as _utils from '@ember/utils';
-export declare const modules: {
+declare const modules: {
     '@ember/application': typeof _application;
     '@ember/array': typeof _array;
     '@ember/component': typeof _EmberComponent;
     '@ember/component/template-only': typeof _TO;
     '@ember/debug': typeof _debug;
     '@ember/destroyable': typeof _destroyable;
-    '@ember/helper': any;
-    '@ember/modifier': any;
+    '@ember/helper': typeof _helpers;
+    '@ember/modifier': typeof _modifier;
     '@ember/object': typeof _object;
     '@ember/runloop': typeof _runloop;
     '@ember/service': typeof _service;
@@ -35,3 +37,4 @@ export declare const modules: {
     '@glimmer/component': typeof _GlimmerComponent;
     '@glimmer/tracking': typeof _tracking;
 };
+export { modules };

package/dist/browser/known-modules.js

@@ -0,0 +1,48 @@
+import _GlimmerComponent from '@glimmer/component';
+import * as _tracking from '@glimmer/tracking';
+import * as _application from '@ember/application';
+import * as _array from '@ember/array';
+import * as _EmberComponent from '@ember/component';
+import _TO from '@ember/component/template-only';
+import * as _debug from '@ember/debug';
+import * as _destroyable from '@ember/destroyable';
+import * as _helpers from '@ember/helper';
+import * as _modifier from '@ember/modifier';
+import * as _object from '@ember/object';
+import * as _runloop from '@ember/runloop';
+import * as _service from '@ember/service';
+import * as _string from '@ember/string';
+import { createTemplateFactory } from '@ember/template-factory';
+import * as _utils from '@ember/utils';
+
+/**
+ * We need to import and hang on to these references so that they
+ * don't get optimized away during deploy
+ */
+// import * as _owner from '@ember/owner';
+
+const modules = {
+  '@ember/application': _application,
+  '@ember/array': _array,
+  '@ember/component': _EmberComponent,
+  '@ember/component/template-only': _TO,
+  '@ember/debug': _debug,
+  '@ember/destroyable': _destroyable,
+  '@ember/helper': _helpers,
+  '@ember/modifier': _modifier,
+  '@ember/object': _object,
+  '@ember/runloop': _runloop,
+  '@ember/service': _service,
+  '@ember/string': _string,
+  '@ember/template-factory': {
+    createTemplateFactory
+  },
+  '@ember/utils': _utils,
+  // '@ember/owner': _owner,
+
+  '@glimmer/component': _GlimmerComponent,
+  '@glimmer/tracking': _tracking
+};
+
+export { modules };
+//# sourceMappingURL=known-modules.js.map

package/dist/browser/known-modules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"known-modules.js","sources":["../../src/browser/known-modules.ts"],"sourcesContent":["/**\n * We need to import and hang on to these references so that they\n * don't get optimized away during deploy\n */\nimport _GlimmerComponent from '@glimmer/component';\nimport * as _tracking from '@glimmer/tracking';\nimport * as _application from '@ember/application';\nimport * as _array from '@ember/array';\nimport * as _EmberComponent from '@ember/component';\nimport _TO from '@ember/component/template-only';\nimport * as _debug from '@ember/debug';\nimport * as _destroyable from '@ember/destroyable';\nimport * as _helpers from '@ember/helper';\nimport * as _modifier from '@ember/modifier';\nimport * as _object from '@ember/object';\nimport * as _runloop from '@ember/runloop';\nimport * as _service from '@ember/service';\nimport * as _string from '@ember/string';\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore\nimport { createTemplateFactory } from '@ember/template-factory';\nimport * as _utils from '@ember/utils';\n// import * as _owner from '@ember/owner';\n\nexport const modules = {\n  '@ember/application': _application,\n  '@ember/array': _array,\n  '@ember/component': _EmberComponent,\n  '@ember/component/template-only': _TO,\n  '@ember/debug': _debug,\n  '@ember/destroyable': _destroyable,\n  '@ember/helper': _helpers,\n  '@ember/modifier': _modifier,\n  '@ember/object': _object,\n  '@ember/runloop': _runloop,\n  '@ember/service': _service,\n  '@ember/string': _string,\n  '@ember/template-factory': { createTemplateFactory },\n  '@ember/utils': _utils,\n  // '@ember/owner': _owner,\n\n  '@glimmer/component': _GlimmerComponent,\n  '@glimmer/tracking': _tracking,\n};\n"],"names":["modules","_application","_array","_EmberComponent","_TO","_debug","_destroyable","_helpers","_modifier","_object","_runloop","_service","_string","createTemplateFactory","_utils","_GlimmerComponent","_tracking"],"mappings":";;;;;;;;;;;;;;;;;AAAA;AACA;AACA;AACA;AAmBA;;AAEO,MAAMA,OAAO,GAAG;AACrB,EAAA,oBAAoB,EAAEC,YAAY;AAClC,EAAA,cAAc,EAAEC,MAAM;AACtB,EAAA,kBAAkB,EAAEC,eAAe;AACnC,EAAA,gCAAgC,EAAEC,GAAG;AACrC,EAAA,cAAc,EAAEC,MAAM;AACtB,EAAA,oBAAoB,EAAEC,YAAY;AAClC,EAAA,eAAe,EAAEC,QAAQ;AACzB,EAAA,iBAAiB,EAAEC,SAAS;AAC5B,EAAA,eAAe,EAAEC,OAAO;AACxB,EAAA,gBAAgB,EAAEC,QAAQ;AAC1B,EAAA,gBAAgB,EAAEC,QAAQ;AAC1B,EAAA,eAAe,EAAEC,OAAO;AACxB,EAAA,yBAAyB,EAAE;AAAEC,IAAAA,qBAAAA;GAAuB;AACpD,EAAA,cAAc,EAAEC,MAAM;AACtB;;AAEA,EAAA,oBAAoB,EAAEC,iBAAiB;AACvC,EAAA,mBAAmB,EAAEC,SAAAA;AACvB;;;;"}

package/dist/browser/types.d.ts

@@ -0,0 +1,17 @@
+import { availablePlugins, availablePresets, transform } from '@babel/standalone';
+import { ComponentLike } from '@glint/template';
+interface CompileResult {
+    component?: ComponentLike;
+    error?: Error;
+    name: string;
+}
+interface Babel {
+    availablePlugins: typeof availablePlugins;
+    availablePresets: typeof availablePresets;
+    transform: typeof transform;
+}
+type Options = {
+    skypack?: boolean;
+};
+type ExtraModules = Record<string, unknown>;
+export { CompileResult, Babel, Options, ExtraModules };

package/dist/browser/types.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.js.map

package/dist/browser/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/{utils.d.ts → dist/browser/utils.d.ts}

@@ -4,11 +4,16 @@
  * This can help with cacheing previously compiled components,
  * and generally allowing a consumer to derive "known references" to user-input
  */
-export declare function nameFor(code: string, prefix?: string): string;
+declare function nameFor(code: string, prefix?: string): string;
 /**
  * Returns the text for invoking a component with a given name.
  * It is assumed the component takes no arguments, as would be the
  * case in REPLs / Playgrounds for the "root" component.
  */
-export declare function invocationOf(name: string): string;
-export declare function invocationName(name: string): string;
+declare function invocationOf(name: string): string;
+/**
+ * Core team does not want to support changes to '@ember/string' (v2 addonification, specifically)
+ * inflection does not support hyphens
+ */
+declare function invocationName(name: string): string;
+export { nameFor, invocationOf, invocationName };

package/dist/browser/utils.js

@@ -0,0 +1,46 @@
+import { assert } from '@ember/debug';
+import { pascalCase } from 'change-case';
+import { v5 } from 'uuid';
+
+/**
+ * a namespace is required for uuid v5
+ *
+ * it helps generate stable outputs for for any given input.
+ */
+const NAMESPACE = '926f034a-f480-4112-a363-321244f4e5de';
+const DEFAULT_PREFIX = 'ember-repl';
+
+/**
+ * For any given code block, a reasonably stable name can be
+ * generated.
+ * This can help with cacheing previously compiled components,
+ * and generally allowing a consumer to derive "known references" to user-input
+ */
+function nameFor(code, prefix = DEFAULT_PREFIX) {
+  let id = v5(code, NAMESPACE);
+  return `${prefix ? `${prefix}-` : ''}${id}`;
+}
+
+/**
+ * Returns the text for invoking a component with a given name.
+ * It is assumed the component takes no arguments, as would be the
+ * case in REPLs / Playgrounds for the "root" component.
+ */
+function invocationOf(name) {
+  assert(`You must pass a name to invocationOf. Received: \`${name}\``, typeof name === 'string' && name.length > 0);
+  if (name.length === 0) {
+    throw new Error(`name passed to invocationOf must have non-0 length`);
+  }
+  return `<${invocationName(name)} />`;
+}
+
+/**
+ * Core team does not want to support changes to '@ember/string' (v2 addonification, specifically)
+ * inflection does not support hyphens
+ */
+function invocationName(name) {
+  return pascalCase(name).replaceAll('_', '');
+}
+
+export { invocationName, invocationOf, nameFor };
+//# sourceMappingURL=utils.js.map

package/dist/browser/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../src/browser/utils.ts"],"sourcesContent":["import { assert } from '@ember/debug';\n\nimport { pascalCase } from 'change-case';\nimport { v5 as uuidv5 } from 'uuid';\n\n/**\n * a namespace is required for uuid v5\n *\n * it helps generate stable outputs for for any given input.\n */\nconst NAMESPACE = '926f034a-f480-4112-a363-321244f4e5de';\nconst DEFAULT_PREFIX = 'ember-repl';\n\n/**\n * For any given code block, a reasonably stable name can be\n * generated.\n * This can help with cacheing previously compiled components,\n * and generally allowing a consumer to derive \"known references\" to user-input\n */\nexport function nameFor(code: string, prefix = DEFAULT_PREFIX) {\n  let id = uuidv5(code, NAMESPACE);\n\n  return `${prefix ? `${prefix}-` : ''}${id}`;\n}\n\n/**\n * Returns the text for invoking a component with a given name.\n * It is assumed the component takes no arguments, as would be the\n * case in REPLs / Playgrounds for the \"root\" component.\n */\nexport function invocationOf(name: string) {\n  assert(\n    `You must pass a name to invocationOf. Received: \\`${name}\\``,\n    typeof name === 'string' && name.length > 0\n  );\n\n  if (name.length === 0) {\n    throw new Error(`name passed to invocationOf must have non-0 length`);\n  }\n\n  return `<${invocationName(name)} />`;\n}\n\n/**\n * Core team does not want to support changes to '@ember/string' (v2 addonification, specifically)\n * inflection does not support hyphens\n */\nexport function invocationName(name: string) {\n  return pascalCase(name).replaceAll('_', '');\n}\n"],"names":["NAMESPACE","DEFAULT_PREFIX","nameFor","code","prefix","id","uuidv5","invocationOf","name","assert","length","Error","invocationName","pascalCase","replaceAll"],"mappings":";;;;AAKA;AACA;AACA;AACA;AACA;AACA,MAAMA,SAAS,GAAG,sCAAsC,CAAA;AACxD,MAAMC,cAAc,GAAG,YAAY,CAAA;;AAEnC;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,OAAOA,CAACC,IAAY,EAAEC,MAAM,GAAGH,cAAc,EAAE;AAC7D,EAAA,IAAII,EAAE,GAAGC,EAAM,CAACH,IAAI,EAAEH,SAAS,CAAC,CAAA;EAEhC,OAAQ,CAAA,EAAEI,MAAM,GAAI,CAAEA,EAAAA,MAAO,GAAE,GAAG,EAAG,CAAEC,EAAAA,EAAG,CAAC,CAAA,CAAA;AAC7C,CAAA;;AAEA;AACA;AACA;AACA;AACA;AACO,SAASE,YAAYA,CAACC,IAAY,EAAE;AACzCC,EAAAA,MAAM,CACH,CAAA,kDAAA,EAAoDD,IAAK,CAAA,EAAA,CAAG,EAC7D,OAAOA,IAAI,KAAK,QAAQ,IAAIA,IAAI,CAACE,MAAM,GAAG,CAC5C,CAAC,CAAA;AAED,EAAA,IAAIF,IAAI,CAACE,MAAM,KAAK,CAAC,EAAE;AACrB,IAAA,MAAM,IAAIC,KAAK,CAAE,CAAA,kDAAA,CAAmD,CAAC,CAAA;AACvE,GAAA;AAEA,EAAA,OAAQ,CAAGC,CAAAA,EAAAA,cAAc,CAACJ,IAAI,CAAE,CAAI,GAAA,CAAA,CAAA;AACtC,CAAA;;AAEA;AACA;AACA;AACA;AACO,SAASI,cAAcA,CAACJ,IAAY,EAAE;EAC3C,OAAOK,UAAU,CAACL,IAAI,CAAC,CAACM,UAAU,CAAC,GAAG,EAAE,EAAE,CAAC,CAAA;AAC7C;;;;"}

package/dist/build/ember-cli.cjs

@@ -0,0 +1,36 @@
+'use strict';
+
+const { stripIndents } = require('common-tags');
+
+/**
+ * Builds a file with a single export, COMPONENT_MAP, that
+ * is a map of the provided paths *to* all exported identifiers
+ * from each of the provided paths.
+ *
+ * This is helpful for building a map of imports to force to be included
+ * in the build - a requirement for builds that tend to tree shake.
+ *
+ * @param {string[]} paths - list of import paths for each module that you want availableb to the REPL
+ */
+module.exports.buildComponentMap = function buildComponentMap(paths) {
+  const writeFile = require('broccoli-file-creator');
+  const fileContent = stripIndents`
+    ${paths
+      .map((path, i) => {
+        return `import * as ComponentMapPart${i} from '${path}';`;
+      })
+      .join('\n')}
+
+    export const COMPONENT_MAP = {
+      ${paths
+        .map((path, i) => {
+          return `'${path}': ComponentMapPart${i},`;
+        })
+        .join('\n')}
+    };
+  `;
+
+  const tree = writeFile('/ember-repl/component-map.js', fileContent);
+
+  return tree;
+};