@playfast/reform 1.0.1 → 1.2.0

package/src/feature/feature.test.ts

@@ -1,17 +1,28 @@
-import { Effect, Layer, Option } from 'effect'
-import { expect, test } from 'vitest'
+import { Effect, Option } from 'effect'
+import { expect, it } from '@effect/vitest'
 import * as Composition from '../compose/composition'
+import { mount } from '../compose/structure'
 import { ui } from '../compose/ui'
 import * as Feature from './feature'
 import { featureModule, isFeature, isFeatureBinding, lazyImport } from './feature'
 
 // Minimal composition surface to hang features off — definitions only, no logic.
 class TestUi extends ui('TestUi')<{ props: {}; events: {} }>() {}
-class TestComp extends Composition.make('TestComp', { title: 'Test', ui: TestUi }) {}
-class FailComp extends Composition.make('FailComp', { title: 'Fail', ui: TestUi }) {}
+class TestComp extends Composition.make('TestComp', {
+  title: 'Test',
+  ui: TestUi,
+})<TestComp>() {}
+class FailComp extends Composition.make('FailComp', {
+  title: 'Fail',
+  ui: TestUi,
+})<FailComp>() {}
 
-// A trivial loaded module: empty layer, no shared requirements.
-const mod = featureModule([], Layer.empty)
+const TestLive = Composition.live(TestComp, function* () {
+  return mount({ props: {}, slots: {} })
+})
+
+// A valid Feature module owns its declared root Composition service.
+const mod = featureModule([], TestLive)
 
 class LazyFeature extends Feature.make('lazyFeature', {
   loadingStrategy: 'lazy',
@@ -20,41 +31,55 @@ class LazyFeature extends Feature.make('lazyFeature', {
   placeholder: { loading: TestComp, failed: FailComp },
 }) {}
 
+class SameShapeFeature extends Feature.make('lazyFeature', {
+  loadingStrategy: 'lazy',
+  composition: TestComp,
+  load: lazyImport(() => Promise.resolve({ default: mod })),
+  placeholder: { loading: TestComp, failed: FailComp },
+}) {}
+
 class EagerFeature extends Feature.make('eagerFeature', {
   composition: TestComp,
   module: mod,
 }) {}
 
-test('a lazy feature reflects as a Feature manifest with placeholders, no chunk loaded', () => {
+const LazyNative = Feature.tree<typeof LazyFeature>(LazyFeature.token)
+const EagerNative = Feature.tree<typeof EagerFeature>(EagerFeature.token)
+
+it('a lazy feature reflects as a Feature manifest with placeholders, no chunk loaded', () => {
   expect(LazyFeature.manifest.kind).toBe('Feature')
   expect(LazyFeature.manifest.name).toBe('lazyFeature')
   expect(LazyFeature.manifest.strategy).toBe('lazy')
   expect(LazyFeature.manifest.composition.name).toBe('TestComp')
   expect(Option.getOrThrow(LazyFeature.manifest.placeholder).loading.name).toBe('TestComp')
   expect(Option.getOrThrow(LazyFeature.manifest.placeholder).failed.name).toBe('FailComp')
-  expect(LazyFeature.eagerModule).toBeUndefined()
+  expect(LazyNative.eagerModule).toBeUndefined()
 })
 
-test('an eager feature reflects as default strategy with its module available', () => {
+it('an eager feature reflects as default strategy with its module available', () => {
   expect(EagerFeature.manifest.strategy).toBe('default')
   expect(Option.isNone(EagerFeature.manifest.placeholder)).toBe(true)
-  expect(EagerFeature.eagerModule).toBe(mod)
+  expect(EagerNative.eagerModule).toBe(mod)
 })
 
-test('isFeature / isFeatureBinding discriminate', () => {
+it('isFeature / isFeatureBinding discriminate', () => {
   expect(isFeature(LazyFeature)).toBe(true)
   expect(isFeature(TestComp)).toBe(false)
   expect(isFeature(null)).toBe(false)
-  expect(isFeatureBinding(LazyFeature.binding)).toBe(true)
+  expect(isFeatureBinding(LazyNative.binding)).toBe(true)
   expect(isFeatureBinding(TestComp)).toBe(false)
+  expect(LazyFeature.token).not.toBe(SameShapeFeature.token)
+  expect(LazyFeature.token.identity).not.toBe(SameShapeFeature.token.identity)
 })
 
-test('load is an Effect (not a thenable) that yields the module and its requires', async () => {
-  // No `.then` on `load` — it is an Effect, run on the Effect runtime.
-  expect(typeof (LazyFeature.load as { then?: unknown }).then).toBe('undefined')
-  const loaded = await Effect.runPromise(LazyFeature.load)
-  expect(loaded.requires).toEqual([])
-  expect(loaded).toBe(mod)
-  // default strategy resolves immediately to its module.
-  expect(await Effect.runPromise(EagerFeature.load)).toBe(mod)
-})
+it.live('load is an Effect (not a thenable) that yields the module and its requires', () =>
+  Effect.gen(function* () {
+    // No `.then` on `load` — it is an Effect, run on the Effect runtime.
+    expect('then' in LazyNative.load).toBe(false)
+    const loaded = yield* LazyNative.load
+    expect(loaded.requires).toEqual([])
+    expect(loaded).toBe(mod)
+    // default strategy resolves immediately to its module.
+    expect(yield* EagerNative.load).toBe(mod)
+  }),
+)