@dungarees/qwik 0.11.6 → 0.12.0

package/behaviors-hook.d.ts

@@ -1,4 +1,4 @@
-import type { ApplicationFactory, BehaviorsTools, RequiredApplicationConfig } from './type.ts';
+import type { ApplicationFactory, BehaviorsTools, RequiredApplicationConfig } from './application.ts';
 export declare const createBehaviorsHook: <const APPLICATION extends RequiredApplicationConfig>({ application, identityTransform, }: {
     application: ApplicationFactory<APPLICATION>;
     identityTransform?: (identity: APPLICATION["identity"]) => APPLICATION["identity"];

package/hooks.d.ts

@@ -1,4 +1,4 @@
-import type { BehaviorByName, BehaviorName, BehaviorsTools, LoadBehaviorsByName, QwikApplicationConfig } from './type.ts';
+import type { BehaviorByName, BehaviorName, BehaviorsTools, LoadBehaviorsByName, QwikApplicationConfig } from './application.ts';
 import { type QRL, type Signal } from '@builder.io/qwik';
 import type { Observable } from 'rxjs';
 export type QwikHooks<APPLICATION extends QwikApplicationConfig> = {

package/package.json

@@ -18,11 +18,11 @@
   },
   "author": "info@productkind.com",
   "license": "MIT",
-  "version": "0.11.6",
+  "version": "0.12.0",
   "exports": {
-    "./behaviors-hook.test.ts": {
-      "import": "./behaviors-hook.test.js",
-      "types": "./behaviors-hook.test.d.ts"
+    "./application.ts": {
+      "import": "./application.js",
+      "types": "./application.d.ts"
     },
     "./behaviors-hook.ts": {
       "import": "./behaviors-hook.js",
@@ -39,10 +39,6 @@
     "./identity.ts": {
       "import": "./identity.js",
       "types": "./identity.d.ts"
-    },
-    "./type.ts": {
-      "import": "./type.js",
-      "types": "./type.d.ts"
     }
   }
 }

package/behaviors-hook.test.js

@@ -1,129 +0,0 @@
-import { createBehaviorsHook } from './behaviors-hook.js';
-import { createApplication } from '@dungarees/core/application.ts';
-import { expect, expectTypeOf, test } from 'vitest';
-const createGreeterApplication = (name = 'greeter1') => createApplication({
-    getBehaviors: [{ pattern: 'key', value: () => ({ greeter: { name } }) }],
-});
-test('loadBehaviors hands back one behaviour by name', () => {
-    const { loadBehaviors } = createBehaviorsHook({ application: () => createGreeterApplication() });
-    expect(loadBehaviors('key', 'greeter').name).toBe('greeter1');
-});
-test('loadBehaviors types the behaviour it hands back', () => {
-    const { loadBehaviors } = createBehaviorsHook({ application: () => createGreeterApplication() });
-    expectTypeOf(loadBehaviors('key', 'greeter')).toEqualTypeOf();
-});
-test('loadBehaviors hands back every behaviour when no name is given', () => {
-    const { loadBehaviors } = createBehaviorsHook({ application: () => createGreeterApplication() });
-    expect(loadBehaviors('key')).toEqual({ greeter: { name: 'greeter1' } });
-});
-test('loadBehaviors types the whole set when no name is given', () => {
-    const { loadBehaviors } = createBehaviorsHook({ application: () => createGreeterApplication() });
-    expectTypeOf(loadBehaviors('key')).toEqualTypeOf();
-});
-test('loadBehaviors reports an identity the application does not cover', () => {
-    const { loadBehaviors } = createBehaviorsHook({ application: () => createGreeterApplication() });
-    // @ts-expect-error 'key2' is not an identity this application declares
-    expect(() => loadBehaviors('key2', 'greeter')).toThrow('Behaviors are not set for "key2"');
-});
-test('loadBehaviors hands back the same instance every time', () => {
-    const { loadBehaviors } = createBehaviorsHook({ application: () => createGreeterApplication() });
-    expect(loadBehaviors('key', 'greeter')).toBe(loadBehaviors('key', 'greeter'));
-});
-test('behaviours set for the server are used instead of running the application', () => {
-    const { loadBehaviors, setServerBehaviors } = createBehaviorsHook({
-        application: () => createGreeterApplication(),
-    });
-    setServerBehaviors({ behaviors: { greeter: { name: 'from-server' } } });
-    expect(loadBehaviors('key', 'greeter').name).toBe('from-server');
-    expect(loadBehaviors('key')).toEqual({ greeter: { name: 'from-server' } });
-});
-test('behaviours set for the server stop the application from running at all', () => {
-    const applicationRuns = [];
-    const { loadBehaviors, setServerBehaviors } = createBehaviorsHook({
-        application: () => {
-            applicationRuns.push(true);
-            return createGreeterApplication();
-        },
-    });
-    setServerBehaviors({ behaviors: { greeter: { name: 'from-server' } } });
-    loadBehaviors('key', 'greeter');
-    loadBehaviors('key', 'greeter');
-    expect(applicationRuns).toEqual([]);
-});
-test('exportBehaviorsState exports through the application', () => {
-    const application = createApplication({
-        exportState: () => 'state',
-        getBehaviors: [{ pattern: 'key', value: () => ({ greeter: { name: 'greeter' } }) }],
-    });
-    const { exportBehaviorsState } = createBehaviorsHook({ application: () => application });
-    expect(exportBehaviorsState('key')).toBe('state');
-});
-test('an export set for the server wins over the application', () => {
-    const application = createApplication({
-        exportState: () => 'state',
-        getBehaviors: [{ pattern: 'key', value: () => ({ greeter: { name: 'greeter' } }) }],
-    });
-    const { exportBehaviorsState, setServerBehaviors } = createBehaviorsHook({
-        application: () => application,
-    });
-    setServerBehaviors({
-        behaviors: { greeter: { name: 'greeter' } },
-        exportState: () => 'other-state',
-    });
-    expect(exportBehaviorsState('key')).toBe('other-state');
-});
-test('exportBehaviorsState fails when neither the application nor the server provides one', () => {
-    const { exportBehaviorsState, setServerBehaviors } = createBehaviorsHook({
-        application: () => createGreeterApplication(),
-    });
-    setServerBehaviors({ behaviors: { greeter: { name: 'greeter' } } });
-    expect(() => exportBehaviorsState('key')).toThrow('Export state is not defined');
-});
-test('importBehaviorsState imports through the application', () => {
-    const imported = [];
-    const application = createApplication({
-        importState: (_, state) => {
-            imported.push(state);
-        },
-        getBehaviors: [{ pattern: 'key', value: () => ({ greeter: { name: 'greeter' } }) }],
-    });
-    const { importBehaviorsState } = createBehaviorsHook({ application: () => application });
-    importBehaviorsState({ identity: 'key', state: 'state' });
-    expect(imported).toEqual(['state']);
-});
-test('the identity can be transformed before the application is run', () => {
-    const seenIdentities = [];
-    const runIdentities = [];
-    const application = createApplication({
-        getBehaviors: [
-            { pattern: 'frontend', value: () => ({ greeter: { name: 'frontend' } }) },
-            { pattern: 'ssr', value: () => ({ greeter: { name: 'ssr' } }) },
-        ],
-        main: (_, identity) => {
-            runIdentities.push(identity);
-        },
-    });
-    const { loadBehaviors } = createBehaviorsHook({
-        application: () => application,
-        identityTransform: (identity) => {
-            seenIdentities.push(identity);
-            return 'frontend';
-        },
-    });
-    loadBehaviors('ssr', 'greeter');
-    expect(seenIdentities).toEqual(['ssr']);
-    expect(runIdentities).toEqual(['frontend']);
-});
-test('the transformed identity is what selects the behaviours', () => {
-    const application = createApplication({
-        getBehaviors: [
-            { pattern: 'frontend', value: () => ({ greeter: { name: 'frontend' } }) },
-            { pattern: 'ssr', value: () => ({ greeter: { name: 'ssr' } }) },
-        ],
-    });
-    const { loadBehaviors } = createBehaviorsHook({
-        application: () => application,
-        identityTransform: () => 'frontend',
-    });
-    expect(loadBehaviors('ssr', 'greeter').name).toBe('frontend');
-});

package/type.js

@@ -1 +0,0 @@
-export {};