astro-accelerator-utils 0.0.33 → 0.0.35

package/index.d.mts

@@ -5,5 +5,7 @@ import * as PostPaging from "./lib/postPaging.mjs";
 import * as Cache from "./lib/cache.mjs";
 import * as Dates from "./lib/dates.mjs";
 import * as Markdown from "./lib/markdown.mjs";
+import * as Navigation from "./lib/navigation.mjs";
+import * as Taxonomy from "./lib/taxonomy.mjs";
 import * as Urls from "./lib/urls.mjs";
-export { PostQueries, PostFiltering, PostOrdering, PostPaging, Cache, Dates, Markdown, Urls };
+export { PostQueries, PostFiltering, PostOrdering, PostPaging, Cache, Dates, Markdown, Navigation, Taxonomy, Urls };

package/index.mjs

@@ -5,6 +5,8 @@ import * as PostPaging from './lib/postPaging.mjs';
 import * as Cache from './lib/cache.mjs';
 import * as Dates from './lib/dates.mjs';
 import * as Markdown from './lib/markdown.mjs';
+import * as Navigation from './lib/navigation.mjs';
+import * as Taxonomy from './lib/taxonomy.mjs';
 import * as Urls from './lib/urls.mjs';
 
 export {
@@ -15,5 +17,7 @@ export {
     Cache,
     Dates,
     Markdown,
+    Navigation,
+    Taxonomy,
     Urls
 };

package/lib/navigation.d.mts

@@ -0,0 +1,26 @@
+/**
+ * @typedef { import("../types/Site").Site } Site
+ * @typedef { import("../types/NavPage").NavPage } NavPage
+ */
+/**
+ *
+ * @param {URL} currentUrl
+ * @param {Site} site
+ * @returns {Promise<NavPage[]}
+ */
+export function getMenu(currentUrl: URL, site: Site): Promise<NavPage[]>;
+/**
+ *
+ * @param {NavPage | 'auto' | 'tags' | 'toptags' | 'categories'} item
+ * @returns {item is NavPage}
+ */
+export function isNavPage(item: NavPage | 'auto' | 'tags' | 'toptags' | 'categories'): item is import("../types/NavPage").NavPage;
+/**
+ *
+ * @param {URL} currentUrl
+ * @param {Site} site
+ * @returns {Promise<NavPage[]}
+ */
+export function getNavigation(currentUrl: URL, site: Site): Promise<NavPage[]>;
+export type Site = import("../types/Site").Site;
+export type NavPage = import("../types/NavPage").NavPage;

package/lib/navigation.mjs

@@ -0,0 +1,111 @@
+import * as PostQueries from './postQueries.mjs';
+import * as PostFiltering from './postFiltering.mjs';
+import * as Cache from './cache.mjs';
+import { menu } from '/src/data/navigation';
+
+/**
+ * @typedef { import("../types/Site").Site } Site
+ * @typedef { import("../types/NavPage").NavPage } NavPage
+ */
+
+/**
+ * 
+ * @param {URL} currentUrl 
+ * @param {Site} site 
+ * @returns {Promise<NavPage[]}
+ */
+export async function getMenu (currentUrl, site) {
+    const key = 'Navigation__getMenu';
+
+    /** @type {NavPage[]} */
+    let pages = await Cache.getItem(key);
+
+    if (pages == null) {
+        pages = [];
+        for (let i = 0; i < menu.length; i++) {
+            const item = menu[i];
+            if (isNavPage(item)) {
+                pages.push(item);
+            } else {
+                const p = await getNavigation(currentUrl, site);
+                for (let j = 0; j < p.length; j++) {
+                    pages.push(p[j]);
+                }
+            }
+        }
+
+        // Cache the result
+        await Cache.setItem(key, pages);
+    }
+
+    PostQueries.setCurrentPage(pages, currentUrl);
+
+    return pages;
+}
+
+/**
+ * 
+ * @param {NavPage | 'auto' | 'tags' | 'toptags' | 'categories'} item 
+ * @returns {item is NavPage}
+ */
+export function isNavPage (item) {
+    if (typeof item === 'string' && ['auto', 'tags', 'toptags', 'categories'].includes(item)) {
+      return false;
+    }
+  
+    return true;
+  }
+  
+
+/**
+ * 
+ * @param {URL} currentUrl 
+ * @param {Site} site 
+ * @returns {Promise<NavPage[]}
+ */
+export async function getNavigation (currentUrl, site) {
+
+    const key = 'Navigation__getNavigation';
+
+    /** @type {NavPage[]} */
+    let pageHierarchy = await Cache.getItem(key);
+
+    if (pageHierarchy == null) {
+        const topLevelPages = await PostQueries.getTopLevelPages(site, PostFiltering.showInMenu);
+        const allPages = await PostQueries.getPages(PostFiltering.showInMenu);
+
+        pageHierarchy = topLevelPages
+            .map(p => PostQueries.mapNavPage(p, site))
+            .sort((a, b) => a.order - b.order);
+            
+        /** @type {NavPage[]} */
+        const pageList = allPages.map(p => PostQueries.mapNavPage(p, site));
+
+        for (let i = 0; i < pageHierarchy.length; i++) {
+            const page = pageHierarchy[i];
+
+            if (i > 0) {
+                // Don't add children to first link (Home)
+                page.children = pageList
+                    .filter((mp) =>
+                        page.url != '/'
+                        && mp.url != page.url
+                        && mp.url.startsWith(page.url)
+                    )
+                    .sort((mp) => mp.order);
+            }
+
+            if (page.children.length > 0) {
+                const ownChild = structuredClone(page);
+                ownChild.order = -1;
+                ownChild.children = [];
+                page.children.push(ownChild);
+            }
+        }
+
+        // Cache the result
+        await Cache.setItem(key, pageHierarchy);
+    }
+
+    return pageHierarchy;
+}

package/lib/taxonomy.d.mts

@@ -0,0 +1,30 @@
+/**
+ * @typedef { import("../types/Taxonomy").Taxonomy } Taxonomy
+ * @typedef { import("../types/Taxonomy").TaxonomyEntry } TaxonomyEntry
+ * @typedef { import("../types/Taxonomy").TaxonomyLinks } TaxonomyLinks
+ * @typedef { import("../types/Astro").MarkdownInstance } MarkdownInstance
+ */
+/**
+ *
+ * @param {TaxonomyEntry} a
+ * @param {TaxonomyEntry} b
+ * @returns
+ */
+export function sortByTitle(a: TaxonomyEntry, b: TaxonomyEntry): 0 | 1 | -1;
+/**
+ *
+ * @param {any} translations
+ * @param {(entry: any) => string} lang
+ * @param {Site} site
+ * @returns {TaxonomyLinks}
+ */
+export function taxonomyLinks(translations: any, lang: (entry: any) => string, site: Site): TaxonomyLinks;
+/**
+ *
+ * @returns {Promise<Taxonomy}
+ */
+export function getTaxonomy(): Promise<Taxonomy>;
+export type Taxonomy = import("../types/Taxonomy").Taxonomy;
+export type TaxonomyEntry = import("../types/Taxonomy").TaxonomyEntry;
+export type TaxonomyLinks = import("../types/Taxonomy").TaxonomyLinks;
+export type MarkdownInstance = import("../types/Astro").MarkdownInstance;

package/lib/taxonomy.mjs

@@ -0,0 +1,121 @@
+import * as Urls from './urls.mjs';
+
+/**
+ * @typedef { import("../types/Taxonomy").Taxonomy } Taxonomy
+ * @typedef { import("../types/Taxonomy").TaxonomyEntry } TaxonomyEntry
+ * @typedef { import("../types/Taxonomy").TaxonomyLinks } TaxonomyLinks
+ * @typedef { import("../types/Astro").MarkdownInstance } MarkdownInstance
+ */
+
+/**
+ * 
+ * @param {TaxonomyEntry} a 
+ * @param {TaxonomyEntry} b 
+ * @returns 
+ */
+export function sortByTitle (a, b) {
+    if ( a.title < b.title ){
+      return -1;
+    }
+  
+    if ( a.title > b.title ){
+      return 1;
+    }
+    
+    return 0;
+}
+
+/**
+ * 
+ * @param {any} translations 
+ * @param {(entry: any) => string} lang 
+ * @param {Site} site 
+ * @returns {TaxonomyLinks}
+ */
+export function taxonomyLinks(translations, lang, site) {
+    const category = lang(translations.articles.category) ?? 'category';
+    const categoryLink = `${site.subfolder}/${category}/`;
+
+    const tag = lang(translations.articles.tag) ?? 'category';
+    const tagLink = `${site.subfolder}/${tag}/`;
+
+    return {
+        tag: tag,
+        category: category,
+        getCategoryLink: (category) => {
+            return Urls.addSlashToAddress(categoryLink + category.toLowerCase().replace(/ /g, '-') + '/1/', site);
+        },
+        getTagLink: (tag) => {
+            return Urls.addSlashToAddress(tagLink + tag.toLowerCase().replace(/ /g, '-') + '/1/', site);
+        }
+    };
+}
+
+/**
+ * 
+ * @returns {Promise<Taxonomy}
+ */
+export async function getTaxonomy () {
+    const cacheKey = 'Global__taxonomy';
+
+    /** @type {Taxonomy} */
+    let taxonomy = await Cache.getItem(cacheKey);
+
+    if (taxonomy == null) {
+        /** @type {MarkdownInstance[]} */
+        const allPages = await PostQueries.getPages();
+        
+        /** @type {{ [key: string]: number }} */
+        const tags = {};
+
+        /** @type {{ [key: string]: number }} */
+        const cats = {};
+
+        // Get taxonomy and counts
+        allPages.forEach((p) => {
+            p.frontmatter.tags && (p.frontmatter.tags).forEach(t => {
+                tags[t] = (tags[t] ?? 0) + 1;
+            });
+
+            p.frontmatter.categories && (p.frontmatter.categories).forEach(c => {
+                cats[c] = (cats[c] ?? 0) + 1;
+            });
+        });
+
+        // Map into the taxonomy
+        taxonomy = {
+            tags: Object.keys(tags).sort().map(x => {
+                return {
+                    title: x,
+                    count: tags[x]
+                };
+            }),
+            topTags: [],
+            categories: Object.keys(cats).sort().map(x => {
+                return {
+                    title: x,
+                    count: cats[x]
+                };
+            })
+        };
+
+        // Get a list of "top tags" by usage count
+        const length = Math.min(taxonomy.categories.length, taxonomy.tags.length);
+        taxonomy.topTags = taxonomy.tags
+            .sort((a, b) => b.count - a.count)
+            .slice(0, length)
+            .sort((a, b) => {
+                if ( a.title < b.title ){
+                    return -1;
+                }
+                if ( a.title > b.title ){
+                    return 1;
+                }
+                return 0;
+             });
+
+        await Cache.setItem(cacheKey, taxonomy);
+    }
+
+    return taxonomy;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-accelerator-utils",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "description": "Astro utilities for Astro Accelerator.",
   "main": "index.mjs",
   "files": [

package/types/Taxonomy.d.ts

@@ -0,0 +1,15 @@
+export interface TaxonomyEntry {
+    title: string;
+    count: number;
+}
+export interface Taxonomy {
+    tags: TaxonomyEntry[];
+    topTags: TaxonomyEntry[];
+    categories: TaxonomyEntry[];
+}
+export interface TaxonomyLinks {
+    tag: string;
+    category: string;
+    getCategoryLink: (category: string) => string;
+    getTagLink: (tag: string) => string;
+}