[REFACTOR] Upstream custom managers, TO managers

packages/@glimmer/benchmark-env/src/benchmark/create-registry.ts

@@ -12,7 +12,7 @@ import {
 } from '@glimmer/interfaces';
 import { programCompilationContext } from '@glimmer/opcode-compiler';
 import { artifacts } from '@glimmer/program';
-import { SimpleComponentManager } from '@glimmer/runtime';
+import { TemplateOnlyComponentManager } from '@glimmer/runtime';
 import { SimpleElement } from '@simple-dom/interface';
 
 import { UpdateBenchmark } from '../interfaces';
@@ -94,7 +94,7 @@ export default function createRegistry(): Registry {
       name: string,
       template: SerializedTemplateWithLazyBlock,
       component: unknown = null,
-      manager: InternalComponentManager = new SimpleComponentManager()
+      manager: InternalComponentManager = new TemplateOnlyComponentManager()
     ) => {
       components.set(
         name,

packages/@glimmer/benchmark-env/src/create-benchmark.ts

@@ -1,17 +1,19 @@
-import { TEMPLATE_ONLY_COMPONENT } from '@glimmer/runtime';
+import { TemplateOnlyComponentManager } from '@glimmer/runtime';
 import { Benchmark } from './interfaces';
 import createRegistry from './benchmark/create-registry';
 import onModifier from './benchmark/on-modifier';
 import ifHelper from './benchmark/if-helper';
 import basicComponentManager from './benchmark/basic-component-manager';
 
+const TEMPLATE_ONLY_COMPONENT_MANAGER = new TemplateOnlyComponentManager();
+
 export default function createBenchmark(): Benchmark {
   const registry = createRegistry();
   registry.registerModifier('on', null, onModifier);
   registry.registerHelper('if', ifHelper);
   return {
     templateOnlyComponent: (name, template) => {
-      registry.registerComponent(name, template, null, TEMPLATE_ONLY_COMPONENT.manager);
+      registry.registerComponent(name, template, null, TEMPLATE_ONLY_COMPONENT_MANAGER);
     },
     basicComponent: (name, template, component) => {
       registry.registerComponent(name, template, component, basicComponentManager);

packages/@glimmer/integration-tests/lib/components.ts

@@ -2,5 +2,4 @@ export * from './components/types';
 export * from './components/capabilities';
 export * from './components/emberish-curly';
 export * from './components/emberish-glimmer';
-export * from './components/template-only';
 export * from './components/test-component';

packages/@glimmer/integration-tests/lib/modes/jit/register.ts

@@ -1,5 +1,4 @@
 import { TestJitRegistry } from './registry';
-import { TemplateOnlyComponentManager } from '../../components/template-only';
 import { TEMPLATE_ONLY_CAPABILITIES, CURLY_CAPABILITIES } from '../../components/capabilities';
 import {
   Option,
@@ -33,10 +32,11 @@ import { TestComponentDefinitionState } from '../../components/test-component';
 import {
   CurriedComponentDefinition,
   curry,
-  setComponentTemplate,
   templateOnlyComponent,
+  TemplateOnlyComponentManager,
 } from '@glimmer/runtime';
 import { createTemplate, preprocess } from '../../compile';
+import { setComponentTemplate } from '@glimmer/manager';
 
 const TEMPLATE_ONLY_COMPONENT_MANAGER = new TemplateOnlyComponentManager();
 const EMBERISH_GLIMMER_COMPONENT_MANAGER = new EmberishGlimmerComponentManager();

packages/@glimmer/integration-tests/lib/modes/jit/registry.ts

@@ -11,7 +11,7 @@ import {
   WithStaticLayout,
 } from '@glimmer/interfaces';
 import { assert, dict, unwrapTemplate } from '@glimmer/util';
-import { getComponentTemplate } from '@glimmer/runtime';
+import { getComponentTemplate } from '@glimmer/manager';
 import { TestComponentDefinitionState } from '../../components/test-component';
 
 // This is used to replicate a requirement of Ember's template referrers, which

packages/@glimmer/integration-tests/package.json

@@ -7,6 +7,7 @@
     "@glimmer/global-context": "0.67.0",
     "@glimmer/reference": "0.67.0",
     "@glimmer/runtime": "0.67.0",
+    "@glimmer/manager": "0.67.0",
     "@glimmer/syntax": "0.67.0",
     "@glimmer/validator": "0.67.0",
     "@glimmer/compiler": "0.67.0",
@@ -16,7 +17,6 @@
     "@glimmer/node": "0.67.0",
     "@glimmer/opcode-compiler": "0.67.0",
     "@glimmer/program": "0.67.0",
-    "@glimmer/bundle-compiler": "^0.60.0",
     "@simple-dom/document": "^1.4.0",
     "@simple-dom/interface": "^1.4.0",
     "@simple-dom/serializer": "^1.4.0",

packages/@glimmer/integration-tests/test/debug-render-tree-test.ts

@@ -17,15 +17,15 @@ import {
   EmberishGlimmerArgs,
   TestComponentDefinitionState,
   createTemplate,
-  TemplateOnlyComponentManager,
   TEMPLATE_ONLY_CAPABILITIES,
 } from '..';
 import {
   EMPTY_ARGS,
-  setComponentTemplate,
   TemplateOnlyComponent,
   templateOnlyComponent,
+  TemplateOnlyComponentManager,
 } from '@glimmer/runtime';
+import { setComponentTemplate } from '@glimmer/manager';
 
 interface CapturedBounds {
   parentElement: SimpleElement;

packages/@glimmer/interfaces/lib/runtime.d.ts

@@ -2,6 +2,7 @@ export * from './runtime/arguments';
 export * from './runtime/debug-render-tree';
 export * from './runtime/element';
 export * from './runtime/environment';
+export * from './runtime/helper';
 export * from './runtime/modifier';
 export * from './runtime/owner';
 export * from './runtime/render';

packages/@glimmer/interfaces/lib/runtime/helper.d.ts

@@ -0,0 +1,14 @@
+// eslint-disable-next-line node/no-extraneous-import
+import { Reference } from '@glimmer/reference';
+import { HelperManager } from '../managers/helper';
+import { VMArguments } from './arguments';
+import { VM } from './vm';
+
+export interface Helper {
+  (args: VMArguments, vm: VM): Reference;
+}
+
+export interface InternalHelperManager {
+  helper: Helper;
+  manager: HelperManager<unknown> | null;
+}

packages/@glimmer/interfaces/lib/runtime/vm.d.ts

@@ -16,7 +16,3 @@ export interface VM {
   getSelf(): Reference;
   associateDestroyable(child: Destroyable): void;
 }
-
-export interface Helper {
-  (args: VMArguments, vm: VM): Reference;
-}

packages/@glimmer/interfaces/lib/serialize.d.ts

@@ -59,9 +59,8 @@ import { ProgramSymbolTable } from './tier1/symbol-table';
 import { ComponentDefinition } from './components';
 import { CompilableProgram, Template, HandleResult } from './template';
 import { CompileTimeCompilationContext } from './program';
-import { Helper } from './runtime/vm';
 import { ModifierDefinition } from './runtime/modifier';
-import { Owner } from './runtime';
+import { Owner, Helper } from './runtime';
 import { InternalComponentCapabilities } from './managers';
 
 export interface HandleResolver {

packages/@glimmer/manager/index.ts

@@ -0,0 +1,14 @@
+export {
+  setInternalHelperManager,
+  setInternalModifierManager,
+  setInternalComponentManager,
+  getInternalHelperManager,
+  getInternalModifierManager,
+  getInternalComponentManager,
+} from './lib/internal/index';
+export { setHelperManager, setModifierManager, setComponentManager } from './lib/public/index';
+export { componentCapabilities, CustomComponentManager } from './lib/public/component';
+export { modifierCapabilities, CustomModifierManager } from './lib/public/modifier';
+export { helperCapabilities, hasDestroyable, hasValue } from './lib/public/helper';
+export { getComponentTemplate, setComponentTemplate } from './lib/public/template';
+export { CUSTOM_TAG_FOR } from './lib/util/args-proxy';

packages/@glimmer/manager/lib/internal/index.ts

@@ -0,0 +1,172 @@
+import { Owner } from '@glimmer/interfaces';
+import { DEBUG } from '@glimmer/env';
+import { debugToString, _WeakSet } from '@glimmer/util';
+import {
+  InternalComponentManager,
+  InternalModifierManager,
+  InternalHelperManager,
+} from '@glimmer/interfaces';
+
+type InternalManager = InternalComponentManager | InternalModifierManager | InternalHelperManager;
+
+const COMPONENT_MANAGERS = new WeakMap<
+  object,
+  InternalManagerFactory<Owner, InternalComponentManager>
+>();
+
+const MODIFIER_MANAGERS = new WeakMap<
+  object,
+  InternalManagerFactory<Owner, InternalModifierManager>
+>();
+
+const HELPER_MANAGERS = new WeakMap<
+  object,
+  InternalManagerFactory<Owner | undefined, InternalHelperManager>
+>();
+
+const OWNER_MANAGER_INSTANCES: WeakMap<
+  Owner,
+  WeakMap<InternalManagerFactory<Owner>, unknown>
+> = new WeakMap();
+const UNDEFINED_MANAGER_INSTANCES: WeakMap<InternalManagerFactory<Owner>, unknown> = new WeakMap();
+
+export type InternalManagerFactory<O, D extends InternalManager = InternalManager> = (
+  owner: O
+) => D;
+
+///////////
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+function setManager<O extends Owner, Def extends object>(
+  map: WeakMap<Def, InternalManagerFactory<O>>,
+  factory: InternalManagerFactory<O> | InternalManagerFactory<O | undefined>,
+  obj: Def
+): Def {
+  if (DEBUG && (typeof obj !== 'object' || obj === null) && typeof obj !== 'function') {
+    throw new Error(
+      `Attempted to set a manager on a non-object value. Managers can only be associated with objects or functions. Value was ${debugToString!(
+        obj
+      )}`
+    );
+  }
+
+  if (DEBUG && map.has(obj)) {
+    throw new Error(
+      `Attempted to set the same type of manager multiple times on a value. You can only associate one manager of each type with a given value. Value was ${debugToString!(
+        obj
+      )}`
+    );
+  }
+
+  map.set(obj, factory);
+  return obj;
+}
+
+function getManager<O, D extends InternalManager>(
+  map: WeakMap<object, InternalManagerFactory<O, D>>,
+  obj: object
+): InternalManagerFactory<O, D> | undefined {
+  let pointer = obj;
+  while (pointer !== undefined && pointer !== null) {
+    const manager = map.get(pointer);
+
+    if (manager !== undefined) {
+      return manager;
+    }
+
+    pointer = getPrototypeOf(pointer);
+  }
+
+  return undefined;
+}
+
+function getManagerInstanceForOwner<D extends InternalManager>(
+  owner: Owner | undefined,
+  factory: InternalManagerFactory<Owner, D>
+): D {
+  let managers;
+
+  if (owner === undefined) {
+    managers = UNDEFINED_MANAGER_INSTANCES;
+  } else {
+    managers = OWNER_MANAGER_INSTANCES.get(owner);
+
+    if (managers === undefined) {
+      managers = new WeakMap();
+      OWNER_MANAGER_INSTANCES.set(owner, managers);
+    }
+  }
+
+  let instance = managers.get(factory);
+
+  if (instance === undefined) {
+    instance = factory(owner!);
+    managers.set(factory, instance!);
+  }
+
+  // We know for sure that it's the correct type at this point, but TS can't know
+  return instance as D;
+}
+
+///////////
+
+export function setInternalModifierManager<O extends Owner>(
+  factory: InternalManagerFactory<O, InternalModifierManager>,
+  definition: object
+) {
+  return setManager(MODIFIER_MANAGERS, factory, definition);
+}
+
+export function getInternalModifierManager(
+  owner: Owner | undefined,
+  definition: object
+): InternalModifierManager | undefined {
+  const factory = getManager(MODIFIER_MANAGERS, definition);
+
+  if (factory !== undefined) {
+    return getManagerInstanceForOwner(owner, factory);
+  }
+
+  return undefined;
+}
+
+export function setInternalHelperManager<O extends Owner>(
+  factory: InternalManagerFactory<O | undefined, InternalHelperManager>,
+  definition: object
+) {
+  return setManager(HELPER_MANAGERS, factory, definition);
+}
+
+export function getInternalHelperManager(
+  owner: Owner | undefined,
+  definition: object
+): InternalHelperManager | undefined {
+  const factory = getManager(HELPER_MANAGERS, definition);
+
+  if (factory !== undefined) {
+    return getManagerInstanceForOwner(owner, factory);
+  }
+
+  return undefined;
+}
+
+export function setInternalComponentManager<O extends Owner>(
+  factory: InternalManagerFactory<O, InternalComponentManager>,
+  obj: object
+) {
+  return setManager(COMPONENT_MANAGERS, factory, obj);
+}
+
+export function getInternalComponentManager(
+  owner: Owner | undefined,
+  definition: object
+): InternalComponentManager | undefined {
+  const factory = getManager<Owner, InternalComponentManager>(COMPONENT_MANAGERS, definition);
+
+  if (factory !== undefined) {
+    return getManagerInstanceForOwner(owner, factory);
+  }
+
+  return undefined;
+}