@d1vij/jassm 0.1.17 → 0.1.18-beta.1

package/README.md

@@ -33,10 +33,10 @@ import react from "@vitejs/plugin-react";
 import jassm from "@d1vij/jassm/plugin";
 
 export default defineConfig({
-    plugins: [
-        jassm(), // Put jassm plugin before react's plugin
-        react(),
-    ],
+  plugins: [
+    jassm(), // Put jassm plugin before react's plugin
+    react(),
+  ],
 });
 ```
 
@@ -56,12 +56,12 @@ echo "# This is a Heading" > sample.mdx
 import { Registry } from "@d1vij/jassm";
 
 export const registry = new Registry({
-    modules: import.meta.glob("/src/assets/mdx/**/*.mdx"),
-    source: "/src/assets/mdx",
-    mountOn: "/root",
-    records: {
-        "/sample": "/example.mdx",
-    },
+  modules: import.meta.glob("/src/assets/mdx/**/*.mdx"),
+  source: "/src/assets/mdx",
+  mountOn: "/root",
+  records: {
+    "/sample": "/example.mdx",
+  },
 });
 ```
 
@@ -75,8 +75,8 @@ import type { StyleClassesMap } from "jassm";
 import "myStyles.css";
 
 export const stylesmap: StyleClassesMap = {
-    header: "myHeader",
-    paragraph: "pee",
+  header: "myHeader",
+  paragraph: "pee",
 };
 ```
 
@@ -88,8 +88,8 @@ import styles from "myStyles.module.css";
 import type { StyleClassesMap } from "jassm";
 
 export const stylesmap: StyleClassesMap = {
-    header: styles.myHeader,
-    paragraph: styles.pee,
+  header: styles.myHeader,
+  paragraph: styles.pee,
 };
 ```
 
@@ -143,17 +143,18 @@ import { stylesmap } from "./stylesmap";
 import { Suspense } from "react";
 
 export default function MyLoader() {
-    const Component = registry["/root/sample"];
-
-    return (
-        <div>
-            <StyleContext styles={stylesmap}>
-                <Suspense>
-                    <Component components={Elements} />
-                </Suspense>
-            </StyleContext>
-        </div>
-    );
+  const Component = registry["/root/sample"];
+
+  return (
+    <div>
+      <StyleContext styles={stylesmap}>
+        <Suspense>
+          <Component components={Elements} />
+        </Suspense>
+      </StyleContext>
+    </div>
+  );
 }
 ```
+
 ---

package/dist/index.d.ts

@@ -31,118 +31,201 @@ declare function generateElementsFrom<
 	B extends boolean = true
 >(elements: E, baseElements?: B): { [K in B extends true ? keyof E | (typeof BaseElementTags)[number] : keyof E] : Element2 };
 /**
-* File extension(s) to accept
+* Utility type that ensures a string starts with `/`
 */
-type MDXFile = `${string}.mdx`;
 type MustStartWithSlash<T extends string> = T extends `/${string}` ? T : never;
+/**
+* Utility type that ensures a string does NOT end with `/`
+*/
 type MustNotEndWithSlash<T extends string> = T extends `${string}/` ? never : T;
 /**
-* Options passed to {@link generateRegistries}
+* Valid path that:
+* - starts with `/`
+* - does not end with `/`
+*/
+type PathCheck<T extends string> = MustStartWithSlash<T> & MustNotEndWithSlash<T>;
+/**
+* Type returned by `import.meta.glob`
+*/
+type WrappedUnknownPromise = () => Promise<unknown>;
+/**
+* Shape of glob result
+*/
+type GlobResult<T> = Record<string, T>;
+/**
+* Removes `.mdx` extension from a path
+*/
+type StripExtension<T extends string> = T extends `${infer P}.mdx` ? P : T;
+/**
+* Replace filesystem root with a virtual route prefix
+*
+* Example:
+*
+* `/src/content/foo.mdx`
+* root = `/src/content`
+* virtual = `/blog`
+*
+* Result:
+* `/blog/foo`
+*/
+type ReplaceRoot<
+	P extends string,
+	Root extends string,
+	Virtual extends string
+> = P extends `${Root}${infer Rest}` ? `${Virtual}${StripExtension<Rest>}` : never;
+/**
+* Derives the route keys produced by the registry
+*
+* Example:
+*
+* `/src/blog/foo.mdx`
+* → `/blog/foo`
+*/
+type RouteKey<
+	Modules extends Record<string, unknown>,
+	Root extends string,
+	Virtual extends string
+> = ReplaceRoot<Extract<keyof Modules, string>, Root, Virtual>;
+/**
+* Options passed to {@link generateRegistry}
 */
 type RegistryOptions<
-	S extends string,
-	M extends string,
-	R extends Record<string, string>
+	MetaType,
+	Modules extends GlobResult<WrappedUnknownPromise>,
+	Root extends string,
+	Virtual extends string
 > = {
 	/**
-	* Module object returned from `import.meta.glob`
-	* @example import.module.glob("/src/assets/mdx/**\/*.mdx")
+	* Module map returned from `import.meta.glob`
+	*/
+	modulesGlob: Modules;
+	/**
+	* Metadata extracted from each MDX file
+	*/
+	metadataGlob: { [K in keyof Modules] : MetaType };
+	/**
+	* Filesystem root path
+	*/
+	root: PathCheck<Root>;
+	/**
+	* Virtual route mount point
+	*/
+	virtual: PathCheck<Virtual>;
+};
+/**
+* Internal function used by {@link Registry}.
+*
+* Builds registry mappings for:
+* - keys
+* - metadata
+* - components
+* - exports
+*/
+declare function generateRegistry<
+	MetaType,
+	Modules extends GlobResult<WrappedUnknownPromise>,
+	Root extends string,
+	Virtual extends string
+>({ modulesGlob, metadataGlob, root, virtual }: RegistryOptions<MetaType, Modules, Root, Virtual>): {
+	/**
+	* List of route keys
 	*/
-	modules: Record<string, () => Promise<unknown>>;
+	keys: RouteKey<Modules, Root, Virtual>[];
 	/**
-	*  Directory from which to resolve the source paths in {@link RegistryOptions.records}
+	* Metadata registry
 	*/
-	source: MustNotEndWithSlash<S> & MustStartWithSlash<S>;
+	metadata: Record<RouteKey<Modules, Root, Virtual>, MetaType>;
 	/**
-	* Virtual base path on which to mount the key of {@link RegistryOptions.records}
+	* React lazy component registry
 	*/
-	mountOn: MustNotEndWithSlash<M> & MustStartWithSlash<M>;
+	components: Record<RouteKey<Modules, Root, Virtual>, React.LazyExoticComponent<React.ComponentType>>;
 	/**
-	* Mappings of virtual path to file paths under {@link RegistryOptions.source}
+	* Raw module registry
 	*/
-	records: { [K in keyof R] : K extends string ? MustNotEndWithSlash<K> & MustStartWithSlash<K> extends never ? never : R[K] extends MustStartWithSlash<R[K]> & MDXFile ? R[K] : never : never };
+	exports: Record<RouteKey<Modules, Root, Virtual>, Promise<Record<string, unknown>>>;
 };
-type RegistryKey<
-	S extends string,
-	M extends string,
-	R extends Record<string, string>
-> = keyof RegistryOf<unknown, S, M, R>;
-/**
-* Constructor for any generic registry with keys in the format of `mount-path/virtual-path` for each virual path passed in {@link RegistryOptions.records}
-*/
-type RegistryOf<
-	T,
-	S extends string,
-	M extends string,
-	R extends Record<string, string>
-> = { [K in keyof RegistryOptions<S, M, R>["records"] as `${RegistryOptions<S, M, R>["mountOn"]}${Extract<K, string>}`] : T };
-/**
-* Registry of react components
-*/
-type ComponentRegistry<
-	S extends string,
-	M extends string,
-	R extends Record<string, string>
-> = RegistryOf<React.LazyExoticComponent<React.ComponentType>, S, M, R>;
-/**
-* Registry of promise objects equivalent to return type of `import(<path>)`
-*/
-type ExportsRegistry<
-	S extends string,
-	M extends string,
-	R extends Record<string, string>
-> = RegistryOf<Promise<Record<string, unknown>>, S, M, R>;
-/**
-* Function to generate Registry mappings, use {@link Registry} class instead of this.
-* @param MDXRegistryOptions
-* @returns Tuple of [{@link ComponentRegistry}, {@link ExportsRegistry}]
-*/
-declare function generateRegistries<
-	S extends string,
-	M extends string,
-	R extends Record<string, string>
->({ modules, source, mountOn, records }: RegistryOptions<S, M, R>): [ComponentRegistry<S, M, R>, ExportsRegistry<S, M, R>];
-/**
-* The returned object has the type of {@link React.ComponentType} + whatever user passes
-*/
-type ExportSingleType<T> = Promise<T & {
-	default: React.ComponentType;
-}>;
-type ExportAllType<T> = { [K in keyof T] : ExportSingleType<T[K]> };
+/**
+* Base class for all registry implementations.
+*
+* Provides type-safe access to:
+* - components
+* - module exports
+* - metadata
+*/
 declare abstract class AbstractRegistry<
-	C extends Record<string, React.LazyExoticComponent<React.ComponentType>>,
-	E extends Record<string, unknown>
+	Keys extends string,
+	Components extends Record<Keys, React.LazyExoticComponent<React.ComponentType>>,
+	Exports extends Record<Keys, unknown>,
+	Metadata extends Record<Keys, unknown>
 > {
-	abstract components: C;
-	abstract exports: E;
-	getComponent<K extends keyof C>(key: K): C[K];
-	getComponents(): C;
-	getExport<
-		T extends object,
-		K extends keyof E
-	>(key: K): ExportSingleType<T>;
-	getExports<T extends Record<keyof C, object> = Record<keyof C, object>>(): ExportAllType<T>;
+	/**
+	* List of registry keys
+	*/
+	abstract readonly keys: readonly Keys[];
+	/**
+	* Lazy component registry
+	*/
+	abstract readonly components: Components;
+	/**
+	* Raw module export registry
+	*/
+	abstract readonly exports: Exports;
+	/**
+	* Metadata registry
+	*/
+	abstract readonly metadata: Metadata;
+	/**
+	* Retrieve a React component by route key
+	*/
+	getComponent<Key extends Keys>(key: Key): Components[Key];
+	/**
+	* Retrieve raw module exports for a route
+	*/
+	getExport<Key extends Keys>(key: Key): Exports[Key];
+	/**
+	* Retrieve metadata for a route
+	*/
+	getMetadata<Key extends Keys>(key: Key): Metadata[Key];
 }
 /**
-* Wrapper class over {@link generateRegistries}. Provides methods to access components and exports from typesafe keys
+* Primary registry implementation.
+*
+* Wraps {@link generateRegistry} and exposes
+* strongly typed access methods.
 */
 declare class Registry<
-	S extends string,
-	M extends string,
-	R extends Record<string, string>
-> extends AbstractRegistry<ComponentRegistry<S, M, R>, ExportsRegistry<S, M, R>> {
-	readonly components: ComponentRegistry<S, M, R>;
-	readonly exports: ExportsRegistry<S, M, R>;
-	constructor(registryOpts: RegistryOptions<S, M, R>);
+	MetaType,
+	Modules extends GlobResult<WrappedUnknownPromise>,
+	Root extends string,
+	Virtual extends string
+> extends AbstractRegistry<RouteKey<Modules, Root, Virtual>, Record<RouteKey<Modules, Root, Virtual>, React.LazyExoticComponent<React.ComponentType>>, Record<RouteKey<Modules, Root, Virtual>, unknown>, Record<RouteKey<Modules, Root, Virtual>, MetaType>> {
+	readonly keys: RouteKey<Modules, Root, Virtual>[];
+	readonly components: Record<RouteKey<Modules, Root, Virtual>, React.LazyExoticComponent<React.ComponentType>>;
+	readonly exports: Record<RouteKey<Modules, Root, Virtual>, unknown>;
+	readonly metadata: Record<RouteKey<Modules, Root, Virtual>, MetaType>;
+	constructor(opts: RegistryOptions<MetaType, Modules, Root, Virtual>);
 }
-type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 /**
-* Registry created by coalesing multiple {@link Registry} instances
+* Utility types used for extracting generics
+* from registry instances.
+*/
+type RegistryKeys<R> = R extends AbstractRegistry<infer K, any, any, any> ? K : never;
+type RegistryComponents<R> = R extends AbstractRegistry<any, infer C, any, any> ? C : never;
+type RegistryExports<R> = R extends AbstractRegistry<any, any, infer E, any> ? E : never;
+type RegistryMetadata<R> = R extends AbstractRegistry<any, any, any, infer M> ? M : never;
+/**
+* Registry created by merging multiple {@link Registry}
+* instances into a single unified registry.
+*
+* Useful for combining multiple MDX content directories
+* into one route registry.
 */
-declare class CoalescedRegistry<R extends readonly AbstractRegistry<Record<string, React.LazyExoticComponent<React.ComponentType>>, Record<string, unknown>>[]> extends AbstractRegistry<Record<keyof UnionToIntersection<R[number]["components"]>, React.LazyExoticComponent<React.ComponentType>>, Record<keyof UnionToIntersection<R[number]["exports"]>, unknown>> {
-	readonly components: Record<keyof UnionToIntersection<R[number]["components"]>, React.LazyExoticComponent<React.ComponentType>>;
-	readonly exports: Record<keyof UnionToIntersection<R[number]["exports"]>, unknown>;
-	constructor(...registries: R);
+declare class CoalescedRegistry<Registries extends AbstractRegistry<any, any, any, any>[]> extends AbstractRegistry<RegistryKeys<Registries[number]>, RegistryComponents<Registries[number]>, RegistryExports<Registries[number]>, RegistryMetadata<Registries[number]>> {
+	readonly keys: RegistryKeys<Registries[number]>[];
+	readonly components: RegistryComponents<Registries[number]>;
+	readonly exports: RegistryExports<Registries[number]>;
+	readonly metadata: RegistryMetadata<Registries[number]>;
+	constructor(...registries: Registries);
 }
 /**
 * List of default style classes
@@ -169,4 +252,4 @@ type MDXFromComponentProps = {
 * Simple way to directly load a component from the Registry
 */
 declare function MDXFromComponent({ source: SourceComponent, styles, fallback, elements }: MDXFromComponentProps): JSX;
-export { useStyles, generateRegistries, generateElementsFrom, StyleContext, StyleClassesMap, StyleClassesList, StyleClasses, RegistryOptions, RegistryOf, RegistryKey, Registry, MDXFromComponentProps, MDXFromComponent, MDXFile, MDXComponent, HeaderLevels, ExportsRegistry, ExportSingleType, ExportAllType, ElementProps, Element2 as Element, ComponentRegistry, CoalescedRegistry, BaseElements, BaseElementTags };
+export { useStyles, generateRegistry, generateElementsFrom, StyleContext, StyleClassesMap, StyleClassesList, StyleClasses, RegistryOptions, Registry, MDXFromComponentProps, MDXFromComponent, MDXComponent, HeaderLevels, ElementProps, Element2 as Element, CoalescedRegistry, BaseElements, BaseElementTags };

package/dist/index.js

@@ -505,57 +505,73 @@ function generateElementsFrom(elements, baseElements = true) {
 }
 // src/lib/Registry.ts
 import { lazy } from "react";
-function generateRegistries({
-  modules,
-  source,
-  mountOn,
-  records
+function generateRegistry({
+  modulesGlob,
+  metadataGlob,
+  root,
+  virtual
 }) {
-  const components = [];
-  const exports = [];
-  for (const [virtual, path] of Object.entries(records)) {
-    const src = `${source}${path}`;
-    const loader = modules[src];
-    if (!loader) {
-      throw new Error(`No such file exsits as ${src}`);
-    }
-    components.push([`${mountOn}${virtual}`, lazy(loader)]);
-    exports.push([`${mountOn}${virtual}`, loader()]);
+  const paths = Object.keys(modulesGlob);
+  const keys = new Array(paths.length);
+  const _components = [];
+  const _exports = [];
+  const _metadata = [];
+  for (const [idx, path] of paths.entries()) {
+    const route = path.replace(root, virtual).replace(".mdx", "");
+    const loader = modulesGlob[path];
+    keys[idx] = route;
+    _components.push([route, lazy(loader)]);
+    _exports.push([route, loader()]);
+    _metadata.push([route, metadataGlob[path]]);
   }
-  return [Object.fromEntries(components), Object.fromEntries(exports)];
+  return {
+    keys,
+    components: Object.fromEntries(_components),
+    exports: Object.fromEntries(_exports),
+    metadata: Object.fromEntries(_metadata)
+  };
 }
 
 class AbstractRegistry {
   getComponent(key) {
     return this.components[key];
   }
-  getComponents() {
-    return this.components;
-  }
   getExport(key) {
     return this.exports[key];
   }
-  getExports() {
-    return this.exports;
+  getMetadata(key) {
+    return this.metadata[key];
   }
 }
 
 class Registry extends AbstractRegistry {
+  keys;
   components;
   exports;
-  constructor(registryOpts) {
+  metadata;
+  constructor(opts) {
     super();
-    [this.components, this.exports] = generateRegistries(registryOpts);
+    const result = generateRegistry(opts);
+    this.keys = result.keys;
+    this.components = result.components;
+    this.exports = result.exports;
+    this.metadata = result.metadata;
   }
 }
 
 class CoalescedRegistry extends AbstractRegistry {
-  components;
-  exports;
+  keys = [];
+  components = {};
+  exports = {};
+  metadata = {};
   constructor(...registries) {
     super();
-    this.components = Object.assign({}, ...registries.map((r) => r.getComponents()));
-    this.exports = Object.assign({}, ...registries.map((r) => r.getExports()));
+    for (const registry of registries) {
+      this.keys.push(...registry.keys);
+      Object.assign(this.components, registry.components);
+      Object.assign(this.exports, registry.exports);
+      Object.assign(this.metadata, registry.metadata);
+    }
   }
 }
 // src/components/Loader.tsx
@@ -578,7 +594,7 @@ function MDXFromComponent({
 }
 export {
   useStyles,
-  generateRegistries,
+  generateRegistry,
   generateElementsFrom,
   StyleContext,
   StyleClassesList,

package/package.json

@@ -1,11 +1,17 @@
 {
     "name": "@d1vij/jassm",
+    "version": "0.1.18-beta.1",
     "description": "Just another static site maker. Create simple content driven sites using MDX and React along with Typescript safety.",
-    "version": "0.1.17",
-    "type": "module",
+    "homepage": "https://github.com/d1vij/jassm",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/d1vij/jassm.git"
+    },
     "files": [
         "dist"
     ],
+    "type": "module",
     "module": "./dist/index.js",
     "types": "./dist/index.d.ts",
     "exports": {
@@ -16,17 +22,11 @@
             }
         },
         "./plugin": {
-            "import": "./dist/vitePlugin.js",
-            "types": "./dist/vitePlugin.d.ts"
+            "types": "./dist/vitePlugin.d.ts",
+            "import": "./dist/vitePlugin.js"
         },
         "./package.json": "./package.json"
     },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/d1vij/jassm.git"
-    },
-    "homepage": "https://github.com/d1vij/jassm",
-    "license": "MIT",
     "publishConfig": {
         "access": "public"
     },
@@ -41,8 +41,11 @@
         "lint": "biome check --fix --unsafe && tsc -b",
         "format": "biome format --write"
     },
+    "dependencies": {
+        "@d1vij/shit-i-always-use": "^0.1.3"
+    },
     "devDependencies": {
-        "@biomejs/biome": "^2.4.4",
+        "@biomejs/biome": "^2.4.6",
         "@types/bun": "^1.3.9",
         "@types/mdx": "^2.0.13",
         "@types/react": "^19.2.14",
@@ -65,9 +68,6 @@
             "optional": true
         }
     },
-    "dependencies": {
-        "@d1vij/shit-i-always-use": "^0.1.3"
-    },
     "simple-git-hooks": {
         "pre-commit": "bun run lint && bun run type-check"
     }