@mdfriday/foundry
Version:
The core engine of MDFriday. Convert Markdown and shortcodes into fully themed static sites – Hugo-style, powered by TypeScript.
242 lines • 7.64 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.TaxonomiesBuilder = exports.TaxonomyList = exports.OrderedTaxonomy = exports.OrderedTaxonomyEntry = exports.Taxonomy = exports.WeightedPages = exports.WeightedPage = void 0;
const log_1 = require("../../../../pkg/log");
// Create domain-specific logger for menu building operations
const log = (0, log_1.getDomainLogger)('site', { component: 'taxonomies-builder' });
// WeightedPage - equivalent to Go's WeightedPage struct
class WeightedPage {
constructor(page, ordinalWeightPage) {
this.page = page;
this.ordinalWeightPage = ordinalWeightPage;
}
// Delegate to the wrapped site page
get Page() {
return this.page;
}
// Delegate to the ordinal weight page for weight/ordinal
weight() {
return this.ordinalWeightPage.weight();
}
ordinal() {
return this.ordinalWeightPage.ordinal();
}
// Additional methods that might be needed
owner() {
return this.ordinalWeightPage.owner();
}
get Permalink() {
return this.page.Permalink;
}
get RelPermalink() {
return this.page.RelPermalink;
}
get Title() {
return this.page.Title;
}
}
exports.WeightedPage = WeightedPage;
// WeightedPages - equivalent to Go's WeightedPages slice with methods
class WeightedPages extends Array {
// Page returns the first page (equivalent to Go's Page method)
page() {
if (this.length === 0) {
log.error('Page called on empty WeightedPages');
return null;
}
return this[0];
}
get Page() {
return this.page();
}
// Pages returns all pages as array
pages() {
return Array.from(this);
}
// sortByWeight sorts the pages by weight (stable sort) - renamed to avoid Array.sort conflict
sortByWeight() {
this.stableSort((a, b) => a.weight() - b.weight());
}
// Count returns the number of pages
count() {
return this.length;
}
get Count() {
return this.count();
}
// Stable sort implementation
stableSort(compareFn) {
// Add original indices to maintain stability
const indexed = this.map((item, index) => ({ item, index }));
indexed.sort((a, b) => {
const result = compareFn(a.item, b.item);
return result !== 0 ? result : a.index - b.index;
});
// Replace array contents with sorted items
this.splice(0, this.length, ...indexed.map(x => x.item));
}
}
exports.WeightedPages = WeightedPages;
// Taxonomy - equivalent to Go's Taxonomy map with methods
class Taxonomy {
constructor() {
this.terms = new Map();
}
// Get pages for a term
get(term) {
return this.terms.get(term);
}
// Set pages for a term
set(term, pages) {
this.terms.set(term, pages);
}
// Has checks if term exists
has(term) {
return this.terms.has(term);
}
// Keys returns all term names
keys() {
return Array.from(this.terms.keys());
}
// Values returns all weighted pages
values() {
return Array.from(this.terms.values());
}
get Values() {
return this.terms;
}
// Entries returns all [term, pages] pairs
entries() {
return Array.from(this.terms.entries());
}
// Size returns number of terms
size() {
return this.terms.size;
}
// ByCount returns an ordered taxonomy sorted by # of pages per key
byCount() {
const entries = this.taxonomyArray();
entries.sort((a, b) => {
const countA = a.weightedPages.length;
const countB = b.weightedPages.length;
if (countA === countB) {
return a.name.localeCompare(b.name);
}
return countB - countA; // Descending order (more pages first)
});
return new OrderedTaxonomy(entries);
}
// TaxonomyArray returns an ordered taxonomy with non-defined order
taxonomyArray() {
const entries = [];
for (const [name, weightedPages] of this.terms.entries()) {
entries.push(new OrderedTaxonomyEntry(name, weightedPages));
}
return entries;
}
}
exports.Taxonomy = Taxonomy;
// OrderedTaxonomyEntry - equivalent to Go's OrderedTaxonomyEntry
class OrderedTaxonomyEntry {
constructor(name, weightedPages) {
this.name = name;
this.weightedPages = weightedPages;
}
// Count returns the count of pages in this taxonomy
count() {
return this.weightedPages.count();
}
// Term returns the name given to this taxonomy
term() {
return this.name;
}
}
exports.OrderedTaxonomyEntry = OrderedTaxonomyEntry;
// OrderedTaxonomy - equivalent to Go's OrderedTaxonomy slice with methods
class OrderedTaxonomy extends Array {
constructor(entries) {
super();
if (entries) {
this.push(...entries);
}
}
// getOneOPage returns one page in the taxonomy, null if there is none
getOneOPage() {
if (this.length === 0) {
return null;
}
return this[0].weightedPages.page();
}
}
exports.OrderedTaxonomy = OrderedTaxonomy;
// TaxonomyList - equivalent to Go's TaxonomyList map
class TaxonomyList {
constructor() {
this.taxonomies = new Map();
}
// Get taxonomy by name
get(taxonomyName) {
return this.taxonomies.get(taxonomyName);
}
// Set taxonomy
set(taxonomyName, taxonomy) {
this.taxonomies.set(taxonomyName, taxonomy);
}
// Has checks if taxonomy exists
has(taxonomyName) {
return this.taxonomies.has(taxonomyName);
}
// Keys returns all taxonomy names
keys() {
return Array.from(this.taxonomies.keys());
}
// Values returns all taxonomies
values() {
return Array.from(this.taxonomies.values());
}
get Values() {
return this.taxonomies;
}
// Entries returns all [name, taxonomy] pairs
entries() {
return Array.from(this.taxonomies.entries());
}
// Size returns number of taxonomies
size() {
return this.taxonomies.size;
}
}
exports.TaxonomyList = TaxonomyList;
class TaxonomiesBuilder {
constructor(contentService) {
this.contentService = contentService;
}
async buildTaxonomiesForLanguage(langIndex, site) {
const taxonomies = new TaxonomyList();
try {
await this.contentService.walkTaxonomies(langIndex, async (taxonomy, term, page) => {
// Initialize taxonomy if it doesn't exist
if (!taxonomies.has(taxonomy)) {
taxonomies.set(taxonomy, new Taxonomy());
}
const tax = taxonomies.get(taxonomy);
// Initialize term if it doesn't exist
if (!tax.has(term)) {
tax.set(term, new WeightedPages());
}
// Create site weighted page (equivalent to Go's siteWeightedPage)
const siteWeightedPage = await site.siteWeightedPage(page);
// Add page to term
const termPages = tax.get(term);
termPages.push(siteWeightedPage);
});
return taxonomies;
}
catch (error) {
log.error(`Failed to create taxonomies: ${error}`);
throw error;
}
}
}
exports.TaxonomiesBuilder = TaxonomiesBuilder;
//# sourceMappingURL=taxonomies-builder.js.map