ember-repl 5.0.1 → 6.0.0

package/src/compile/formats/markdown.ts

@@ -63,7 +63,7 @@ function isBelow(meta: string) {
 
 // TODO: extract and publish remark plugin
 function liveCodeExtraction(options: Options = {}) {
-  let { copyComponent, snippets, demo } = options;
+  const { copyComponent, snippets, demo } = options;
   let { classList: snippetClasses } = snippets || {};
   let { classList: demoClasses } = demo || {};
 
@@ -73,7 +73,8 @@ function liveCodeExtraction(options: Options = {}) {
   function isRelevantCode(node: Code): node is RelevantCode {
     if (node.type !== 'code') return false;
 
-    let { meta, lang } = node;
+    let { meta } = node;
+    const { lang } = node;
 
     meta = meta?.trim();
 
@@ -88,7 +89,7 @@ function liveCodeExtraction(options: Options = {}) {
     return true;
   }
 
-  let copyNode = {
+  const copyNode = {
     type: 'html',
     value: copyComponent,
   };
@@ -123,7 +124,7 @@ function liveCodeExtraction(options: Options = {}) {
       if (index === null || index === undefined) return;
 
       if (!isRelevantCode(node as Code)) {
-        let enhanced = enhance(node as Code);
+        const enhanced = enhance(node as Code);
 
         parent.children[index] = enhanced;
 
@@ -134,26 +135,26 @@ function liveCodeExtraction(options: Options = {}) {
 
       seen.add(node);
 
-      let { meta, lang, value } = node as Code;
+      const { meta, lang, value } = node as Code;
 
       if (!meta) return 'skip';
       if (!lang) return 'skip';
 
       file.data.liveCode ??= [];
 
-      let code = value.trim();
-      let name = nameFor(code);
+      const code = value.trim();
+      const name = nameFor(code);
       let invocation = invocationOf(name);
 
-      let shadow = options.shadowComponent;
+      const shadow = options.shadowComponent;
 
-      let wrapInShadow = shadow && !meta?.includes('no-shadow');
+      const wrapInShadow = shadow && !meta?.includes('no-shadow');
 
       if (wrapInShadow) {
         invocation = `<${shadow}>${invocation}</${shadow}>`;
       }
 
-      let invokeNode = {
+      const invokeNode = {
         type: 'html',
         data: {
           hProperties: { [GLIMDOWN_RENDER]: true },
@@ -161,7 +162,7 @@ function liveCodeExtraction(options: Options = {}) {
         value: `<div class="${demoClasses}">${invocation}</div>`,
       };
 
-      let wrapper = enhance(node as Code);
+      const wrapper = enhance(node as Code);
 
       file.data.liveCode.push({
         lang,
@@ -169,9 +170,9 @@ function liveCodeExtraction(options: Options = {}) {
         code,
       });
 
-      let live = isLive(meta);
-      let preview = isPreview(meta);
-      let below = isBelow(meta);
+      const live = isLive(meta);
+      const preview = isPreview(meta);
+      const below = isBelow(meta);
 
       if (live && preview && below) {
         flatReplaceAt(parent.children, index, [wrapper, invokeNode]);
@@ -227,7 +228,7 @@ function buildCompiler(options: ParseMarkdownOptions) {
     options.remarkPlugins.forEach((plugin) => {
       // Arrays are how plugins are passed options (for some reason?)
       // why not just invoke the the function?
-      let p = Array.isArray(plugin) ? plugin : [plugin];
+      const p = Array.isArray(plugin) ? plugin : [plugin];
 
       compiler = compiler.use(...(p as [any]));
     });
@@ -256,7 +257,7 @@ function buildCompiler(options: ParseMarkdownOptions) {
   compiler = compiler.use(() => (tree: Node) => {
     visit(tree, function (node) {
       // We rely on an implicit transformation of data.hProperties => properties
-      let properties = (node as any).properties;
+      const properties = (node as any).properties;
 
       if (properties?.[GLIMDOWN_PREVIEW]) {
         return 'skip';
@@ -295,7 +296,7 @@ function buildCompiler(options: ParseMarkdownOptions) {
     options.rehypePlugins.forEach((plugin) => {
       // Arrays are how plugins are passed options (for some reason?)
       // why not just invoke the the function?
-      let p = Array.isArray(plugin) ? plugin : [plugin];
+      const p = Array.isArray(plugin) ? plugin : [plugin];
 
       compiler = compiler.use(...(p as [any]));
     });
@@ -335,10 +336,10 @@ export async function parseMarkdown(
   input: string,
   options: ParseMarkdownOptions = {}
 ): Promise<LiveCodeExtraction> {
-  let markdownCompiler = buildCompiler(options);
-  let processed = await markdownCompiler.process(input);
-  let liveCode = (processed.data as LiveData).liveCode || [];
-  let templateOnly = processed.toString();
+  const markdownCompiler = buildCompiler(options);
+  const processed = await markdownCompiler.process(input);
+  const liveCode = (processed.data as LiveData).liveCode || [];
+  const templateOnly = processed.toString();
 
   return { templateOnlyGlimdown: templateOnly, blocks: liveCode };
 }

package/src/compile/formats.ts

@@ -1,11 +1,10 @@
 import { invocationName } from './utils.ts';
 
 import type { ExtractedCode } from './formats/markdown.ts';
-import type { CompileResult, UnifiedPlugin } from './types.ts';
-import type { EvalImportMap, ScopeMap } from './types.ts';
+import type { CompileResult, EvalImportMap, ScopeMap, UnifiedPlugin } from './types.ts';
 
 async function compileGJSArray(js: { code: string }[], importMap?: EvalImportMap) {
-  let modules = await Promise.all(
+  const modules = await Promise.all(
     js.map(async ({ code }) => {
       return await compileGJS(code, importMap);
     })
@@ -19,7 +18,7 @@ export async function compileGJS(
   importMap?: EvalImportMap
 ): Promise<CompileResult> {
   try {
-    let { compileJS } = await import('./formats/gjs/index.ts');
+    const { compileJS } = await import('./formats/gjs/index.ts');
 
     return await compileJS(gjsInput, importMap);
   } catch (error) {
@@ -35,7 +34,7 @@ export async function compileHBS(
   }
 ): Promise<CompileResult> {
   try {
-    let { compileHBS } = await import('./formats/hbs.ts');
+    const { compileHBS } = await import('./formats/hbs.ts');
 
     return compileHBS(hbsInput, options);
   } catch (error) {
@@ -50,13 +49,13 @@ async function extractScope(
     topLevelScope?: ScopeMap;
   }
 ): Promise<CompileResult[]> {
-  let scope: CompileResult[] = [];
+  const scope: CompileResult[] = [];
 
-  let hbs = liveCode.filter((code) => code.lang === 'hbs');
-  let js = liveCode.filter((code) => ['js', 'gjs'].includes(code.lang));
+  const hbs = liveCode.filter((code) => code.lang === 'hbs');
+  const js = liveCode.filter((code) => ['js', 'gjs'].includes(code.lang));
 
   if (js.length > 0) {
-    let compiled = await compileGJSArray(js, options?.importMap);
+    const compiled = await compileGJSArray(js, options?.importMap);
 
     await Promise.all(
       compiled.map(async (info) => {
@@ -75,8 +74,8 @@ async function extractScope(
     );
   }
 
-  for (let { code } of hbs) {
-    let compiled = await compileHBS(code, { scope: options?.topLevelScope });
+  for (const { code } of hbs) {
+    const compiled = await compileHBS(code, { scope: options?.topLevelScope });
 
     scope.push(compiled);
   }
@@ -95,7 +94,7 @@ export async function compileMD(
     ShadowComponent?: string;
   }
 ): Promise<CompileResult & { rootTemplate?: string }> {
-  let topLevelScope = options?.topLevelScope ?? {};
+  const topLevelScope = options?.topLevelScope ?? {};
   let rootTemplate: string;
   let liveCode: ExtractedCode[];
   let scope: CompileResult[] = [];
@@ -110,8 +109,8 @@ export async function compileMD(
    *         compiled rootTemplate can invoke them
    */
   try {
-    let { parseMarkdown } = await import('./formats/markdown.ts');
-    let { templateOnlyGlimdown, blocks } = await parseMarkdown(glimdownInput, {
+    const { parseMarkdown } = await import('./formats/markdown.ts');
+    const { templateOnlyGlimdown, blocks } = await parseMarkdown(glimdownInput, {
       CopyComponent: options?.CopyComponent,
       ShadowComponent: options?.ShadowComponent,
       remarkPlugins: options?.remarkPlugins,
@@ -145,7 +144,7 @@ export async function compileMD(
    * can render the 'Ember' and still highlight the correct line?
    * or maybe there is a way to highlight in the editor instead?
    */
-  for (let { error, component } of scope) {
+  for (const { error, component } of scope) {
     if (!component) {
       if (error) {
         return { error, rootTemplate, name: 'unknown' };
@@ -157,7 +156,7 @@ export async function compileMD(
    * Step 4: Compile the Ember Template
    */
   try {
-    let localScope = scope.reduce(
+    const localScope = scope.reduce(
       (accum, { component, name }) => {
         accum[invocationName(name)] = component;
 

package/src/compile/index.ts

@@ -7,9 +7,9 @@ import {
 } from './formats.ts';
 import { nameFor } from './utils.ts';
 
-import type { CompileResult, UnifiedPlugin } from './types.ts';
-import type { EvalImportMap, ScopeMap } from './types.ts';
+import type { CompileResult, EvalImportMap, ScopeMap, UnifiedPlugin } from './types.ts';
 import type { ComponentLike } from '@glint/template';
+
 type Format = 'glimdown' | 'gjs' | 'hbs';
 
 export const CACHE = new Map<string, ComponentLike>();
@@ -80,10 +80,10 @@ export async function compile(
   text: string,
   options: GlimdownOptions | GJSOptions | HBSOptions
 ): Promise<void> {
-  let { onSuccess, onError, onCompileStart } = options;
-  let id = nameFor(`${options.format}:${text}`);
+  const { onSuccess, onError, onCompileStart } = options;
+  const id = nameFor(`${options.format}:${text}`);
 
-  let existing = CACHE.get(id);
+  const existing = CACHE.get(id);
 
   if (existing) {
     onSuccess(existing);
@@ -179,15 +179,15 @@ export function Compiled(
   maybeOptions?: Format | (() => Format) | ExtraOptions | (() => ExtraOptions)
 ): Value {
   return resource(() => {
-    let maybeObject = typeof maybeOptions === 'function' ? maybeOptions() : maybeOptions;
-    let format =
+    const maybeObject = typeof maybeOptions === 'function' ? maybeOptions() : maybeOptions;
+    const format =
       (typeof maybeObject === 'string' ? maybeObject : maybeObject?.format) || 'glimdown';
-    let options = (typeof maybeObject === 'string' ? {} : maybeObject) || {};
+    const options = (typeof maybeObject === 'string' ? {} : maybeObject) || {};
 
-    let input = typeof markdownText === 'function' ? markdownText() : markdownText;
-    let ready = cell(false);
-    let error = cell<string | null>();
-    let result = cell<ComponentLike>();
+    const input = typeof markdownText === 'function' ? markdownText() : markdownText;
+    const ready = cell(false);
+    const error = cell<string | null>();
+    const result = cell<ComponentLike>();
 
     if (input) {
       compile(input, {

package/src/compile/utils.ts

@@ -18,7 +18,7 @@ const DEFAULT_PREFIX = 'ember-repl';
  * and generally allowing a consumer to derive "known references" to user-input
  */
 export function nameFor(code: string, prefix = DEFAULT_PREFIX) {
-  let id = uuidv5(code, NAMESPACE);
+  const id = uuidv5(code, NAMESPACE);
 
   return `${prefix ? `${prefix}-` : ''}${id}`;
 }