astro-accelerator-utils 0.2.2 → 0.2.4

package/index.d.mts

@@ -1,3 +1,4 @@
+import { Accelerator } from "./lib/v1/accelerator.mjs";
 import * as PostFiltering from "./lib/postFiltering.mjs";
 import * as PostOrdering from "./lib/postOrdering.mjs";
-export { Factory, PostFiltering, PostOrdering };
+export { Accelerator, PostFiltering, PostOrdering };

package/index.mjs

@@ -1,10 +1,10 @@
-import { Factory } from './lib/v1/_factory.mjs';
+import { Accelerator } from './lib/v1/accelerator.mjs';
 
 import * as PostFiltering from './lib/postFiltering.mjs';
 import * as PostOrdering from './lib/postOrdering.mjs';
 
 export {
-    Factory,
+    Accelerator,
     PostFiltering,
     PostOrdering
 };

package/lib/v1/accelerator.d.mts

@@ -0,0 +1,31 @@
+/**
+ * @typedef { import("../../types/Site").Site } Site
+ */
+export class Accelerator {
+    /**
+     * @param {Site} site
+     */
+    constructor(site: Site);
+    cacheMaxAge: number;
+    dateOptions: Intl.DateTimeFormatOptions;
+    siteUrl: string;
+    get authors(): Authors;
+    get cache(): Cache;
+    get dateFormatter(): DateFormatter;
+    get markdown(): Markdown;
+    get navigation(): Navigation;
+    get paging(): Paging;
+    get posts(): Posts;
+    get taxonomy(): Taxonomy;
+    get urlFormatter(): UrlFormatter;
+}
+export type Site = import("../../types/Site").Site;
+import { Authors } from "./authors.mjs";
+import { Cache } from "./cache.mjs";
+import { DateFormatter } from "./dates.mjs";
+import { Markdown } from "./markdown.mjs";
+import { Navigation } from "./navigation.mjs";
+import { Paging } from "./paging.mjs";
+import { Posts } from "./posts.mjs";
+import { Taxonomy } from "./taxonomy.mjs";
+import { UrlFormatter } from "./urls.mjs";

package/lib/v1/accelerator.mjs

@@ -19,7 +19,7 @@ export class Accelerator {
     constructor(site) {
         this.cacheMaxAge = site.cacheMaxAge;
         this.dateOptions = site.dateOptions;
-        this.siteUrl = site.siteUrl;
+        this.siteUrl = site.url;
     }
 
     get authors() {

package/lib/v1/authors.d.mts

@@ -0,0 +1,28 @@
+/**
+ * @typedef { import("../../types/AuthorList").AuthorList } AuthorList
+ * @typedef { import("../../types/Astro").MarkdownInstance } MarkdownInstance
+ * @typedef { import("../../types/Frontmatter").Frontmatter } Frontmatter
+ */
+export class Authors {
+    /**
+     * Constructor
+     * @param {Posts} posts
+     */
+    constructor(posts: Posts);
+    posts: Posts;
+    /**
+     * Gets a list of authors, and exposes main author and contributors
+     * @param {Frontmatter} frontmatter
+     * @returns {AuthorList}
+     */
+    forPost(frontmatter: Frontmatter): AuthorList;
+    /**
+     * Get a single author by id/slug
+     * @param {string} slug
+     * @returns {MarkdownInstance}
+     */
+    info(slug: string): MarkdownInstance;
+}
+export type AuthorList = import("../../types/AuthorList").AuthorList;
+export type MarkdownInstance = import("../../types/Astro").MarkdownInstance;
+export type Frontmatter = import("../../types/Frontmatter").Frontmatter;

package/lib/v1/cache.d.mts

@@ -0,0 +1,43 @@
+export class Cache {
+    /**
+     * Constructor
+     * @param {number} maxAge
+     */
+    constructor(maxAge: number);
+    maxAge: number;
+    /**
+     * Gets an item from the cache, falls back to supplied function
+     * @param {string} key
+     * @param {() => any} func
+     */
+    get(key: string, func: () => any): any;
+    /**
+     * Gets an item from the cache
+     * @param {string} key
+     * @returns {Promise<any>}
+     */
+    getItem(key: string): Promise<any>;
+    /**
+     * Adds an item to the cache
+     * @param {string} key
+     * @param {any} value
+     * @returns {Promise<void>}
+     */
+    setItem(key: string, value: any): Promise<void>;
+    /**
+     * Clears the cache
+     * @returns {Promise<void>}
+     */
+    clear(): Promise<void>;
+    /**
+ * Get's the path of the cache files
+ * @returns {string}
+ */
+    getCachePath(): string;
+    /**
+     * Gets the file path for a cache item
+     * @param {string} key
+     * @returns {string}
+     */
+    getItemPath(key: string): string;
+}

package/lib/v1/dates.d.mts

@@ -0,0 +1,19 @@
+/**
+ * @typedef { import("../types/Site") } Site
+ */
+export class DateFormatter {
+    /**
+     * Constructor
+     * @param {Intl.DateTimeFormatOptions} dateOptions
+     */
+    constructor(dateOptions: Intl.DateTimeFormatOptions);
+    dateOptions: Intl.DateTimeFormatOptions;
+    /**
+     * Returns the formatted pubDate
+     * @param {string | Date} date
+     * @param {string} lang
+     * @returns {string}
+     */
+    formatDate(date: string | Date, lang: string): string;
+}
+export type Site = any;

package/lib/v1/markdown.d.mts

@@ -0,0 +1,20 @@
+export class Markdown {
+    /**
+     * Converts markdown to HTML without wrapping in a <p>
+     * @param {string} markdown
+     * @returns {Promise<string>}
+     */
+    getInlineHtmlFrom(markdown: string): Promise<string>;
+    /**
+     * Converts markdown to HTML
+     * @param {string} markdown
+     * @returns {Promise<string>}
+     */
+    getHtmlFrom(markdown: string): Promise<string>;
+    /**
+     * Converts markdown to plain text
+     * @param {string} markdown
+     * @returns {Promise<string>}
+     */
+    getTextFrom(markdown: string): Promise<string>;
+}

package/lib/v1/navigation.d.mts

@@ -0,0 +1,110 @@
+/**
+ * @typedef { import("./posts.mjs").Posts } Posts
+ * @typedef { import("./taxonomy.mjs").Taxonomy } Taxonomy
+ * @typedef { import("./urls.mjs").UrlFormatter } UrlFormatter
+ * @typedef { import("../../types/Astro").MarkdownInstance } MarkdownInstance
+ * @typedef { import("../../types/NavPage").NavPage } NavPage
+ */
+export class Navigation {
+    /**
+     * Constructor
+     * @param {Posts} posts
+     * @param {UrlFormatter} urlFormatter
+     * @param {Taxonomy} taxonomy
+     */
+    constructor(posts: Posts, urlFormatter: UrlFormatter, taxonomy: Taxonomy);
+    posts: import("./posts.mjs").Posts;
+    urlFormatter: import("./urls.mjs").UrlFormatter;
+    taxonomy: import("./taxonomy.mjs").Taxonomy;
+    /**
+     * Returns a list of breadcrumbs
+     * @param {URL} currentUrl
+     * @param {string} subfolder
+     * @returns {NavPage[]}
+     */
+    breadcrumbs(currentUrl: URL, subfolder: string): NavPage[];
+    /**
+     *
+     * @param {URL} currentUrl
+     * @param {string} subfolder
+     * @param {(NavPage | 'auto')[]} menu
+     * @returns {NavPage[]}
+     */
+    menu(currentUrl: URL, subfolder: string, menu: (NavPage | 'auto')[]): NavPage[];
+    /**
+     *
+     * @param {string} subfolder
+     * @returns {NavPage[]}
+     */
+    autoMenu(subfolder: string): NavPage[];
+    /**
+     *
+     * @param {URL} currentUrl
+     * @param {TranslationProvider} _
+     * @param {any} translations
+     * @param {string} subfolder
+     * @param {(NavPage | 'categories' | 'tags' | 'toptags')[]} menu
+     * @returns {NavPage[]}
+     */
+    footer(currentUrl: URL, _: TranslationProvider, translations: any, subfolder: string, menu: (NavPage | 'categories' | 'tags' | 'toptags')[]): NavPage[];
+    /**
+     *
+     * @param {TaxonomyLinks} links
+     * @param {TranslationProvider} _
+     * @param {any} translations
+     * @param {string} subfolder
+     * @param {TaxonomyList} entries
+     * @returns {NavPage[]}
+     */
+    getCategories(links: TaxonomyLinks, _: TranslationProvider, translations: any, subfolder: string, entries: TaxonomyList): NavPage[];
+    /**
+     *
+     * @param {TaxonomyLinks} links
+     * @param {TranslationProvider} _
+     * @param {any} translations
+     * @param {string} subfolder
+     * @param {TaxonomyList} entries
+     * @returns {NavPage[]}
+     */
+    getTags(links: TaxonomyLinks, _: TranslationProvider, translations: any, subfolder: string, entries: TaxonomyList): NavPage[];
+    /**
+     *
+     * @param {TaxonomyLinks} links
+     * @param {TranslationProvider} _
+     * @param {any} translations
+     * @param {string} subfolder
+     * @param {TaxonomyList} entries
+     * @returns {NavPage[]}
+     */
+    getTopTags(links: TaxonomyLinks, _: TranslationProvider, translations: any, subfolder: string, entries: TaxonomyList): NavPage[];
+    /**
+     * Walks a NavPage tree to set current page
+     * @param {NavPage[]} pages
+     * @param {URL} currentUrl
+     */
+    setCurrentPage(pages: NavPage[], currentUrl: URL): void;
+    /**
+     * Converts a MarkdownInstance into a NavPage
+     * @param {MarkdownInstance} page
+     * @returns {NavPage}
+     */
+    mapNavPage(page: MarkdownInstance): NavPage;
+    /**
+     * Checks whether the item is a NavPage
+     * @param {NavPage | 'auto' | 'tags' | 'toptags' | 'categories'} item
+     * @returns {item is NavPage}
+     */
+    isNavPage(item: NavPage | 'auto' | 'tags' | 'toptags' | 'categories'): item is import("../../types/NavPage").NavPage;
+    /**
+     * Pops matching page from array
+     * @param {MarkdownInstance[]} allPages
+     * @param {string} search
+     * @returns
+     */
+    popMatchingPage(allPages: MarkdownInstance[], search: string): import("../../types/Astro").MarkdownInstance;
+}
+export type Posts = import("./posts.mjs").Posts;
+export type Taxonomy = import("./taxonomy.mjs").Taxonomy;
+export type UrlFormatter = import("./urls.mjs").UrlFormatter;
+export type MarkdownInstance = import("../../types/Astro").MarkdownInstance;
+export type NavPage = import("../../types/NavPage").NavPage;

package/lib/v1/paging.d.mts

@@ -0,0 +1,15 @@
+/**
+ * @typedef { import("../types/Link").Link } Link
+ */
+export class Paging {
+    /**
+     * Provides a list of paging links, 1 ... 3 4 5 ... 7
+     * @param {number} limit
+     * @param {number} numberOfPages
+     * @param {number} currentPage
+     * @param {string} url
+     * @returns {Link[]}
+     */
+    links(limit: number, numberOfPages: number, currentPage: number, url: string): Link[];
+}
+export type Link = any;

package/lib/v1/posts.d.mts

@@ -0,0 +1,26 @@
+/**
+ * @typedef { import("../../types/Astro").MarkdownInstance } MarkdownInstance
+ * @typedef { import("./cache.mjs").Cache } Cache
+ */
+export class Posts {
+    /**
+     * Constructor
+     * @param {Cache} cache
+     * @param {() => MarkdownInstance[]} [fetchAll]
+     */
+    constructor(cache: Cache, fetchAll?: () => MarkdownInstance[]);
+    cache: import("./cache.mjs").Cache;
+    fetchAll: () => any;
+    /**
+     * Gets all markdown posts in the site
+     * @returns {MarkdownInstance[]}
+     */
+    all(): MarkdownInstance[];
+    /**
+     * Gets top-level markdown posts in the site
+     * @returns {MarkdownInstance[]}
+     */
+    root(subfolder: any): MarkdownInstance[];
+}
+export type MarkdownInstance = import("../../types/Astro").MarkdownInstance;
+export type Cache = import("./cache.mjs").Cache;

package/lib/v1/taxonomy.d.mts

@@ -0,0 +1,62 @@
+/**
+ * @typedef { import("./cache.mjs").Cache } Cache
+ * @typedef { import("./posts.mjs").Posts } Posts
+ * @typedef { import("./urls.mjs").UrlFormatter } UrlFormatter
+ * @typedef { import("../../types/Site").Site } Site
+ * @typedef { import("../../types/Taxonomy").TaxonomyList } TaxonomyList
+ * @typedef { import("../../types/Taxonomy").TaxonomyEntry } TaxonomyEntry
+ * @typedef { import("../../types/Taxonomy").TaxonomyLinks } TaxonomyLinks
+ * @typedef { import("../../types/Astro").MarkdownInstance } MarkdownInstance
+ */
+export class Taxonomy {
+    /**
+     * Constructor
+     * @param {Cache} cache
+     * @param {Posts} posts
+     * @param {UrlFormatter} urlFormatter
+     */
+    constructor(cache: Cache, posts: Posts, urlFormatter: UrlFormatter);
+    cache: import("./cache.mjs").Cache;
+    posts: import("./posts.mjs").Posts;
+    urlFormatter: import("./urls.mjs").UrlFormatter;
+    /**
+     *
+     * @returns {TaxonomyList}
+     */
+    all(): TaxonomyList;
+    /**
+     *
+     * @param {any} translations
+     * @param {(entry: any) => string} lang
+     * @param {string} subfolder
+     * @returns {TaxonomyLinks}
+     */
+    links(translations: any, lang: (entry: any) => string, subfolder: string): TaxonomyLinks;
+    /**
+     *
+     * @returns {TaxonomyList}
+     */
+    getTaxonomy(): TaxonomyList;
+    /**
+     * Sorts taxonomy entries by title
+     * @param {TaxonomyEntry} a
+     * @param {TaxonomyEntry} b
+     * @returns
+     */
+    sortByTitle(a: TaxonomyEntry, b: TaxonomyEntry): 0 | 1 | -1;
+    /**
+     * Sorts taxonomy entries by title
+     * @param {TaxonomyEntry} a
+     * @param {TaxonomyEntry} b
+     * @returns
+     */
+    sortByVolume(a: TaxonomyEntry, b: TaxonomyEntry): number;
+}
+export type Cache = import("./cache.mjs").Cache;
+export type Posts = import("./posts.mjs").Posts;
+export type UrlFormatter = import("./urls.mjs").UrlFormatter;
+export type Site = import("../../types/Site").Site;
+export type TaxonomyList = import("../../types/Taxonomy").TaxonomyList;
+export type TaxonomyEntry = import("../../types/Taxonomy").TaxonomyEntry;
+export type TaxonomyLinks = import("../../types/Taxonomy").TaxonomyLinks;
+export type MarkdownInstance = import("../../types/Astro").MarkdownInstance;

package/lib/v1/urls.d.mts

@@ -0,0 +1,20 @@
+export class UrlFormatter {
+    /**
+     * Constructor
+     * @param {string} siteUrl
+     */
+    constructor(siteUrl: string);
+    siteUrl: string;
+    /**
+     * Ensures trailing slash is used
+     * @param {URL} url
+     * @returns {URL}
+     */
+    addSlashToUrl(url: URL): URL;
+    /**
+     * Ensures trailing slash is used
+     * @param {string | undefined} address
+     * @returns {string}
+     */
+    addSlashToAddress(address: string | undefined): string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro-accelerator-utils",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Astro utilities for Astro Accelerator.",
   "main": "index.mjs",
   "type": "module",

package/types/AuthorList.d.ts

@@ -0,0 +1,8 @@
+import type { MarkdownInstance } from "./Astro";
+import type { BannerImage } from "./BannerImage";
+export interface AuthorList {
+    image: BannerImage | null;
+    writers: MarkdownInstance[];
+    mainAuthor: MarkdownInstance | null;
+    contributors: MarkdownInstance[];
+}

package/types/BannerImage.d.ts

@@ -0,0 +1,4 @@
+export interface BannerImage {
+    src: string;
+    alt: string;
+}

package/types/NavPage.d.ts

@@ -0,0 +1,10 @@
+export interface NavPage {
+    section?: string;
+    title: string;
+    url: string;
+    order: number;
+    isOpen: boolean;
+    ariaCurrent: 'page' | false;
+    children: NavPage[];
+    rel?: string;
+}

package/types/Site.d.ts

@@ -0,0 +1,35 @@
+export type Site = {
+    url: string;
+    dateOptions: Intl.DateTimeFormatOptions;
+    subfolder: string;
+    feedUrl: string;
+    title: string;
+    description: string;
+    defaultLanguage: string;
+    themeColor: string;
+    owner: string;
+    default: {
+        lang: string;
+        locale: string;
+        dir: string;
+    };
+    search: {
+        fallbackUrl: 'https://www.google.com/search' | string;
+        fallbackSite: 'q' | string;
+        fallbackQuery: 'q' | string;
+    };
+    pageSize: number;
+    pageLinks: number;
+    rssLimit: number;
+    cacheMaxAge: number;
+    featureFlags: {
+        codeBlocks: 'copy'[];
+        figures: 'enlarge'[];
+        youTubeLinks: 'embed'[];
+    };
+    images: {
+        contentSize: string;
+        listerSize: string;
+        authorSize: string;
+    };
+};

package/types/Taxonomy.d.ts

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