repl-sdk 1.0.3 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "repl-sdk",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "type": "module",
   "exports": {
     ".": {

package/src/compilers/ember/gjs.js

@@ -1,5 +1,4 @@
-import { cache } from '../../cache.js';
-import { renderApp } from './render-app-island.js';
+import { makeOwner } from './owner.js';
 
 let elementId = 0;
 
@@ -168,35 +167,12 @@ export async function compiler(config, api) {
 
       element.setAttribute(attribute, '');
 
-      const [application, destroyable, resolver, router, route, testWaiters, runloop] =
-        await compiler.tryResolveAll([
-          '@ember/application',
-          '@ember/destroyable',
-          'ember-resolver',
-          '@ember/routing/router',
-          '@ember/routing/route',
-          '@ember/test-waiters',
-          '@ember/runloop',
-        ]);
-
-      // We don't want to await here, because we need to early
-      // return the element so that the app can render in to it.
-      // (Ember will only render in to an element if it's present in the DOM)
-      return renderApp({
-        element,
-        selector: `[${attribute}]`,
-        component: compiled,
-        log: compiler.announce,
-        modules: {
-          application,
-          destroyable,
-          resolver,
-          router,
-          route,
-          testWaiters,
-          runloop,
-        },
-      });
+      const { renderComponent } = await compiler.tryResolve('@ember/renderer');
+
+      const owner = makeOwner(config.owner);
+      const result = renderComponent(compiled, { into: element, owner });
+
+      return () => result.destroy();
     },
     handlers: {
       js: async (text) => {

package/src/compilers/ember/gmd.js

@@ -3,7 +3,6 @@
  */
 import { assert, isRecord } from '../../utils.js';
 import { buildCodeFenceMetaUtils } from '../markdown/utils.js';
-import { renderApp } from './render-app-island.js';
 
 let elementId = 0;
 
@@ -15,6 +14,7 @@ let elementId = 0;
  *   rehypePlugins: Plugin[],
  *   ShadowComponent: string | undefined,
  *   CopyComponent: string | undefined
+ *   owner?: unknown | undefined
  *   }}
  */
 export function filterOptions(options) {
@@ -29,6 +29,7 @@ export function filterOptions(options) {
   }
 
   return {
+    owner: options?.owner,
     scope: /** @type {Record<string, unknown>}*/ (options?.scope || {}),
     remarkPlugins: /** @type {Plugin[]}*/ (options?.remarkPlugins || []),
     rehypePlugins: /** @type {Plugin[]}*/ (options?.rehypePlugins || []),
@@ -95,36 +96,15 @@ export async function compiler(config, api) {
 
       element.setAttribute(attribute, '');
 
-      const [application, destroyable, resolver, router, route, testWaiters, runloop] =
-        await compiler.tryResolveAll([
-          '@ember/application',
-          '@ember/destroyable',
-          'ember-resolver',
-          '@ember/routing/router',
-          '@ember/routing/route',
-          '@ember/test-waiters',
-          '@ember/runloop',
-        ]);
-
-      // We don't want to await here, because we need to early
-      // return the element so that the app can render in to it.
-      // (Ember will only render in to an element if it's present in the DOM)
-      const destroy = await renderApp({
-        element,
-        selector: `[${attribute}]`,
-        component: compiled,
-        log: compiler.announce,
-        modules: {
-          application,
-          destroyable,
-          resolver,
-          router,
-          route,
-          testWaiters,
-          runloop,
-        },
+      const { renderComponent } = await compiler.tryResolve('@ember/renderer');
+
+      const result = renderComponent(compiled, {
+        into: element,
+        owner: userOptions.owner,
       });
 
+      const destroy = () => result.destroy();
+
       /**
        * @type {(() => void)[]}
        */

package/src/compilers/ember/hbs.js

@@ -1,5 +1,5 @@
 import { isRecord } from '../../utils.js';
-import { renderApp } from './render-app-island.js';
+import { makeOwner } from './owner.js';
 
 let elementId = 0;
 
@@ -65,32 +65,11 @@ export async function compiler(config, api) {
 
       element.setAttribute(attribute, '');
 
-      const [application, destroyable, resolver, router, route, testWaiters, runloop] =
-        await compiler.tryResolveAll([
-          '@ember/application',
-          '@ember/destroyable',
-          'ember-resolver',
-          '@ember/routing/router',
-          '@ember/routing/route',
-          '@ember/test-waiters',
-          '@ember/runloop',
-        ]);
+      const { renderComponent } = await compiler.tryResolve('@ember/renderer');
+      const owner = makeOwner(config.owner);
+      const result = renderComponent(compiled, { into: element, owner });
 
-      return renderApp({
-        element,
-        selector: `[${attribute}]`,
-        component: compiled,
-        log: compiler.announce,
-        modules: {
-          application,
-          destroyable,
-          resolver,
-          router,
-          route,
-          testWaiters,
-          runloop,
-        },
-      });
+      return () => result.destroy();
     },
   };
 

package/src/compilers/ember/owner.js

@@ -0,0 +1,30 @@
+/**
+ * @param {unknown} [owner]
+ */
+export function makeOwner(owner) {
+  return {
+    name: 'inner owner',
+    /**
+     * @param {string} name
+     */
+    lookup(name) {
+      if (typeof owner !== 'object') return;
+      if (!owner) return;
+      if (!('lookup' in owner)) return;
+      if (typeof owner.lookup !== 'function') return;
+
+      return owner.lookup(name);
+    },
+    /**
+     * @param {string} name
+     */
+    resolveRegistration(name) {
+      if (typeof owner !== 'object') return;
+      if (!owner) return;
+      if (!('resolveRegistration' in owner)) return;
+      if (typeof owner.resolveRegistration !== 'function') return;
+
+      return owner.resolveRegistration(name);
+    },
+  };
+}

package/src/compilers/ember/render-app-island.js

@@ -1,83 +0,0 @@
-/** @type {any} */
-let bootWaiter;
-/** @type {any} */
-let createWaiter;
-
-/**
- * Wait to boot the app until the Element is in the DOM.
- * because This old way of making a whole app requires that the element
- * be present in the app.
- *
- * We really need renderComponent(...)
- *   https://github.com/emberjs/ember.js/pull/20781
- *
- * @param {{
- *  element: Element,
- *  modules: { [name: string]: any},
- *  selector: string,
- *  log: (type: 'error' | 'info', message: string) => void;
- *  component: unknown
- * }} options
- */
-export async function renderApp({ element, modules, selector, component, log }) {
-  const App = modules.application.default;
-  const registerDestructor = modules.destroyable.registerDestructor;
-  const destroy = modules.destroyable.destroy;
-  const Resolver = modules.resolver.default;
-  const Router = modules.router.default;
-  const Route = modules.route.default;
-  const schedule = modules.runloop.schedule;
-
-  bootWaiter ||= modules.testWaiters.buildWaiter('repl-output:waiting-for-boot');
-  createWaiter ||= modules.testWaiters.buildWaiter('repl-output:waiting-for-creation');
-
-  const bootToken = bootWaiter.beginAsync();
-  const createToken = createWaiter.beginAsync();
-
-  class EphemeralApp extends App {
-    modulePrefix = 'ephemeral-render-output';
-    rootElement = element;
-    Resolver = Resolver.withModules({
-      'ephemeral-render-output/templates/application': { default: component },
-      'ephemeral-render-output/routes/application': {
-        default: class Application extends Route {
-          /**
-           * @param {unknown[]} args
-           */
-          constructor(...args) {
-            super(...args);
-
-            registerDestructor(() => {
-              bootWaiter.endAsync(bootToken);
-            });
-          }
-          afterModel() {
-            schedule('afterRender', () => {
-              requestAnimationFrame(() => {
-                log('info', 'Ember Island Rendered');
-                bootWaiter.endAsync(bootToken);
-                createWaiter.endAsync(createToken);
-              });
-            });
-          }
-        },
-      },
-      'ephemeral-render-output/router': {
-        default: class BoilerplateRouter extends Router {
-          location = 'none';
-          rootURL = '/';
-        },
-      },
-    });
-  }
-
-  log('info', 'Booting Ember Island');
-
-  const app = EphemeralApp.create({
-    rootElement: element,
-  });
-
-  return () => {
-    destroy(app);
-  };
-}