@esmx/router-vue 3.0.0-rc.103

package/package.json

@@ -0,0 +1,85 @@
+{
+    "name": "@esmx/router-vue",
+    "description": "Vue integration for @esmx/router - A universal router that works seamlessly with both Vue 2.7+ and Vue 3",
+    "keywords": [
+        "vue",
+        "router",
+        "routing",
+        "vue-router",
+        "composition-api",
+        "typescript",
+        "universal",
+        "vue2",
+        "vue3",
+        "navigation",
+        "esmx",
+        "esm",
+        "single-page-application",
+        "spa",
+        "framework",
+        "frontend"
+    ],
+    "template": "library",
+    "scripts": {
+        "lint:js": "biome check --write --no-errors-on-unmatched",
+        "lint:css": "pnpm run lint:js",
+        "lint:type": "tsc --noEmit",
+        "test": "vitest run --pass-with-no-tests",
+        "coverage": "vitest run --coverage --pass-with-no-tests",
+        "build": "unbuild"
+    },
+    "contributors": [
+        {
+            "name": "lzxb",
+            "url": "https://github.com/lzxb"
+        },
+        {
+            "name": "RockShi1994",
+            "url": "https://github.com/RockShi1994"
+        },
+        {
+            "name": "jerrychan7",
+            "url": "https://github.com/jerrychan7"
+        },
+        {
+            "name": "wesloong",
+            "url": "https://github.com/wesloong"
+        }
+    ],
+    "peerDependencies": {
+        "vue": "^3.5.0 || ^2.7.0"
+    },
+    "dependencies": {
+        "@esmx/router": "3.0.0-rc.103"
+    },
+    "devDependencies": {
+        "@biomejs/biome": "2.3.7",
+        "@types/node": "^24.0.0",
+        "@vitest/coverage-v8": "3.2.4",
+        "typescript": "5.9.3",
+        "unbuild": "3.6.1",
+        "vitest": "3.2.4",
+        "vue": "3.5.23",
+        "vue2": "npm:vue@2.7.16"
+    },
+    "version": "3.0.0-rc.103",
+    "type": "module",
+    "private": false,
+    "exports": {
+        ".": {
+            "import": "./dist/index.mjs",
+            "types": "./dist/index.d.ts"
+        }
+    },
+    "module": "dist/index.mjs",
+    "types": "./dist/index.d.ts",
+    "files": [
+        "lib",
+        "src",
+        "dist",
+        "*.mjs",
+        "template",
+        "public"
+    ],
+    "gitHead": "1f2c436d0d57d587756c4012fbf5df2bebcc874f"
+}

package/src/index.test.ts

@@ -0,0 +1,273 @@
+/**
+ * @vitest-environment happy-dom
+ */
+import { describe, expect, it } from 'vitest';
+import * as RouterVueModule from './index';
+
+describe('index.ts - Package Entry Point', () => {
+    describe('Composition API Exports', () => {
+        it('should export useRouter function', () => {
+            expect(RouterVueModule.useRouter).toBeDefined();
+            expect(typeof RouterVueModule.useRouter).toBe('function');
+        });
+
+        it('should export useRoute function', () => {
+            expect(RouterVueModule.useRoute).toBeDefined();
+            expect(typeof RouterVueModule.useRoute).toBe('function');
+        });
+
+        it('should export useProvideRouter function', () => {
+            expect(RouterVueModule.useProvideRouter).toBeDefined();
+            expect(typeof RouterVueModule.useProvideRouter).toBe('function');
+        });
+
+        it('should export useLink function', () => {
+            expect(RouterVueModule.useLink).toBeDefined();
+            expect(typeof RouterVueModule.useLink).toBe('function');
+        });
+
+        it('should export useRouterViewDepth function', () => {
+            expect(RouterVueModule.useRouterViewDepth).toBeDefined();
+            expect(typeof RouterVueModule.useRouterViewDepth).toBe('function');
+        });
+
+        it('should export getRouterViewDepth function', () => {
+            expect(RouterVueModule.getRouterViewDepth).toBeDefined();
+            expect(typeof RouterVueModule.getRouterViewDepth).toBe('function');
+        });
+    });
+
+    describe('Options API Exports', () => {
+        it('should export getRouter function', () => {
+            expect(RouterVueModule.getRouter).toBeDefined();
+            expect(typeof RouterVueModule.getRouter).toBe('function');
+        });
+
+        it('should export getRoute function', () => {
+            expect(RouterVueModule.getRoute).toBeDefined();
+            expect(typeof RouterVueModule.getRoute).toBe('function');
+        });
+    });
+
+    describe('Component Exports', () => {
+        it('should export RouterLink component', () => {
+            expect(RouterVueModule.RouterLink).toBeDefined();
+            expect(typeof RouterVueModule.RouterLink).toBe('object');
+            expect(RouterVueModule.RouterLink.name).toBe('RouterLink');
+            expect(typeof RouterVueModule.RouterLink.setup).toBe('function');
+        });
+
+        it('should export RouterView component', () => {
+            expect(RouterVueModule.RouterView).toBeDefined();
+            expect(typeof RouterVueModule.RouterView).toBe('object');
+            expect(RouterVueModule.RouterView.name).toBe('RouterView');
+            expect(typeof RouterVueModule.RouterView.setup).toBe('function');
+        });
+    });
+
+    describe('Plugin Exports', () => {
+        it('should export RouterPlugin', () => {
+            expect(RouterVueModule.RouterPlugin).toBeDefined();
+            expect(typeof RouterVueModule.RouterPlugin).toBe('object');
+            expect(typeof RouterVueModule.RouterPlugin.install).toBe(
+                'function'
+            );
+        });
+    });
+
+    describe('Export Completeness', () => {
+        it('should export all expected functions and components', () => {
+            const expectedExports = [
+                // Composition API
+                'useRouter',
+                'useRoute',
+                'useProvideRouter',
+                'useLink',
+                'useRouterViewDepth',
+                'getRouterViewDepth',
+                // Options API
+                'getRouter',
+                'getRoute',
+                // Components
+                'RouterLink',
+                'RouterView',
+                // Plugin
+                'RouterPlugin'
+            ];
+
+            expectedExports.forEach((exportName) => {
+                expect(RouterVueModule).toHaveProperty(exportName);
+                expect(Object.hasOwn(RouterVueModule, exportName)).toBe(true);
+            });
+        });
+
+        it('should not export unexpected items', () => {
+            const actualExports = Object.keys(RouterVueModule);
+            const expectedExports = [
+                'useRouter',
+                'useRoute',
+                'useProvideRouter',
+                'useLink',
+                'useRouterViewDepth',
+                'getRouterViewDepth',
+                'getRouter',
+                'getRoute',
+                'RouterLink',
+                'RouterView',
+                'RouterPlugin'
+            ];
+
+            // Check that we don't have unexpected exports
+            const unexpectedExports = actualExports.filter(
+                (exportName) => !expectedExports.includes(exportName)
+            );
+
+            expect(unexpectedExports).toEqual([]);
+        });
+    });
+
+    describe('Function Signatures', () => {
+        it('should have correct function signatures for Composition API', () => {
+            // These should throw expected errors when called without proper context
+            expect(() => {
+                RouterVueModule.useRouter();
+            }).toThrow(
+                '[@esmx/router-vue] Must be used within setup() or other composition functions'
+            );
+
+            expect(() => {
+                RouterVueModule.useRoute();
+            }).toThrow(
+                '[@esmx/router-vue] Must be used within setup() or other composition functions'
+            );
+
+            expect(() => {
+                RouterVueModule.useLink({
+                    to: '/test',
+                    type: 'push',
+                    exact: 'include'
+                });
+            }).toThrow(
+                '[@esmx/router-vue] Must be used within setup() or other composition functions'
+            );
+        });
+
+        it('should have correct function signatures for Options API', () => {
+            expect(() => {
+                RouterVueModule.getRouter({} as Record<string, unknown>);
+            }).toThrow(
+                '[@esmx/router-vue] Router context not found. Please ensure useProvideRouter() is called in a parent component.'
+            );
+
+            expect(() => {
+                RouterVueModule.getRoute({} as Record<string, unknown>);
+            }).toThrow(
+                '[@esmx/router-vue] Router context not found. Please ensure useProvideRouter() is called in a parent component.'
+            );
+        });
+    });
+
+    describe('Component Properties', () => {
+        it('should have RouterLink with correct properties', () => {
+            const { RouterLink } = RouterVueModule;
+
+            expect(RouterLink.name).toBe('RouterLink');
+            expect(RouterLink.props).toBeDefined();
+            expect(RouterLink.setup).toBeDefined();
+
+            // Check required props
+            expect(RouterLink.props.to).toBeDefined();
+            expect(RouterLink.props.to.required).toBe(true);
+
+            // Check default props
+            expect(RouterLink.props.type.default).toBe('push');
+            expect(RouterLink.props.exact.default).toBe('include');
+            expect(RouterLink.props.tag.default).toBe('a');
+            expect(RouterLink.props.event.default).toBe('click');
+        });
+
+        it('should have RouterView with correct properties', () => {
+            const { RouterView } = RouterVueModule;
+
+            expect(RouterView.name).toBe('RouterView');
+            expect(RouterView.setup).toBeDefined();
+            // RouterView should not have props
+            expect(RouterView.props).toBeUndefined();
+        });
+    });
+
+    describe('Plugin Interface', () => {
+        it('should have RouterPlugin with install method', () => {
+            const { RouterPlugin } = RouterVueModule;
+
+            expect(RouterPlugin.install).toBeDefined();
+            expect(typeof RouterPlugin.install).toBe('function');
+
+            // Test plugin install signature - should throw for null input
+            expect(() => {
+                RouterPlugin.install(null);
+            }).toThrow('[@esmx/router-vue] Invalid Vue app instance');
+        });
+    });
+
+    describe('Module Structure', () => {
+        it('should be a proper ES module', () => {
+            // Check that the module exports are properly structured
+            expect(typeof RouterVueModule).toBe('object');
+            expect(RouterVueModule).not.toBeNull();
+
+            // Verify it's not a default export
+            expect('default' in RouterVueModule).toBe(false);
+        });
+
+        it('should have consistent export naming', () => {
+            // All function exports should be camelCase
+            const functionExports = [
+                'useRouter',
+                'useRoute',
+                'useProvideRouter',
+                'useLink',
+                'useRouterViewDepth',
+                'getRouterViewDepth',
+                'getRouter',
+                'getRoute'
+            ];
+
+            functionExports.forEach((exportName) => {
+                expect(exportName).toMatch(/^[a-z][a-zA-Z]*$/);
+            });
+
+            // Component exports should be PascalCase
+            const componentExports = [
+                'RouterLink',
+                'RouterView',
+                'RouterPlugin'
+            ];
+
+            componentExports.forEach((exportName) => {
+                expect(exportName).toMatch(/^[A-Z][a-zA-Z]*$/);
+            });
+        });
+    });
+
+    describe('TypeScript Integration', () => {
+        it('should provide proper TypeScript types', () => {
+            // These checks verify that TypeScript types are properly exported
+            // The actual type checking is done by the TypeScript compiler
+
+            // Verify functions have proper types
+            expect(typeof RouterVueModule.useRouter).toBe('function');
+            expect(typeof RouterVueModule.useRoute).toBe('function');
+            expect(typeof RouterVueModule.getRouter).toBe('function');
+            expect(typeof RouterVueModule.getRoute).toBe('function');
+
+            // Verify components have proper structure
+            expect(RouterVueModule.RouterLink).toHaveProperty('name');
+            expect(RouterVueModule.RouterLink).toHaveProperty('props');
+            expect(RouterVueModule.RouterLink).toHaveProperty('setup');
+
+            expect(RouterVueModule.RouterView).toHaveProperty('name');
+            expect(RouterVueModule.RouterView).toHaveProperty('setup');
+        });
+    });
+});

package/src/index.ts

@@ -0,0 +1,15 @@
+export { RouterPlugin } from './plugin';
+export { RouterLink } from './router-link';
+export { RouterView } from './router-view';
+export {
+    getRoute,
+    getRouter,
+    getRouterViewDepth,
+    useLink,
+    useProvideRouter,
+    useRoute,
+    useRouter,
+    useRouterViewDepth
+} from './use';
+export type * from './vue2';
+export type * from './vue3';