@mdfriday/foundry
Version:
The core engine of MDFriday. Convert Markdown and shortcodes into fully themed static sites – Hugo-style, powered by TypeScript.
256 lines • 6.7 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ShortcodeTemplateNamespace = exports.PartialTemplateNamespace = exports.RegularTemplateNamespace = void 0;
exports.newRegularTemplateNamespace = newRegularTemplateNamespace;
exports.newPartialTemplateNamespace = newPartialTemplateNamespace;
exports.newShortcodeTemplateNamespace = newShortcodeTemplateNamespace;
const type_1 = require("../type");
/**
* Base namespace for template storage with common functionality
* Abstract base class for different template namespace types
*/
class BaseNamespace {
constructor() {
this.templates = new Map();
this.mutex = new Set(); // Simple mutex simulation
}
/**
* Add template to namespace
*/
addTemplate(name, state) {
this.withLock(() => {
this.templates.set(name, state);
});
}
/**
* Find template in namespace
*/
findTemplate(name) {
return this.withReadLock(() => {
if (this.templates.has(name)) {
return this.templates.get(name) || null;
}
for (const [key, template] of this.templates.entries()) {
if (key.includes(name)) {
return template;
}
}
return null;
});
}
/**
* Get all templates
*/
getTemplates() {
return this.withReadLock(() => {
return new Map(this.templates);
});
}
/**
* Check if template exists
*/
hasTemplate(name) {
return this.withReadLock(() => {
return this.templates.has(name);
});
}
/**
* Get template names
*/
getTemplateNames() {
return this.withReadLock(() => {
return Array.from(this.templates.keys());
});
}
/**
* Remove template
*/
removeTemplate(name) {
return this.withLock(() => {
return this.templates.delete(name);
});
}
/**
* Clear all templates
*/
clear() {
this.withLock(() => {
this.templates.clear();
});
}
/**
* Get template count
*/
size() {
return this.withReadLock(() => {
return this.templates.size;
});
}
/**
* Get templates by pattern
*/
getTemplatesByPattern(pattern) {
return this.withReadLock(() => {
const results = [];
for (const [name, state] of this.templates) {
if (pattern.test(name)) {
results.push(state);
}
}
return results;
});
}
/**
* Simple lock mechanism for thread safety simulation
*/
withLock(fn) {
const lockKey = 'write';
while (this.mutex.has(lockKey)) {
// Simple busy wait - in real implementation, use proper async locks
}
this.mutex.add(lockKey);
try {
return fn();
}
finally {
this.mutex.delete(lockKey);
}
}
/**
* Simple read lock mechanism
*/
withReadLock(fn) {
const lockKey = 'read';
this.mutex.add(lockKey);
try {
return fn();
}
finally {
this.mutex.delete(lockKey);
}
}
}
/**
* Regular template namespace - supports baseof dependencies and template keywords
* Handles complex template dependencies and inheritance
*/
class RegularTemplateNamespace extends BaseNamespace {
/**
* Lookup template by name with dependency support
*/
lookup(name) {
const state = this.findTemplate(name);
if (!state) {
return null;
}
return state.template;
}
/**
* Find template with dependency information for baseof processing
*/
findTemplateWithDependencies(name) {
return this.findTemplate(name);
}
/**
* Get templates that need baseof
*/
getTemplatesNeedingBase() {
return this.withReadLock(() => {
return Array.from(this.templates.values()).filter(state => state.baseInfo);
});
}
}
exports.RegularTemplateNamespace = RegularTemplateNamespace;
/**
* Partial template namespace - simple lookup, no template keyword support
* For templates in the partials/ directory
*/
class PartialTemplateNamespace extends BaseNamespace {
/**
* Simple lookup for partial templates
*/
lookup(name) {
const state = this.findTemplate(name);
if (!state) {
return null;
}
return state.template;
}
/**
* Add partial template with validation
*/
addPartialTemplate(name, state) {
// Ensure it's marked as partial type
const partialState = {
...state,
type: type_1.TemplateType.TypePartial
};
this.addTemplate(name, partialState);
}
}
exports.PartialTemplateNamespace = PartialTemplateNamespace;
/**
* Shortcode template namespace - simplest lookup, no dependencies allowed
* For shortcode templates with content-focused rendering
*/
class ShortcodeTemplateNamespace extends BaseNamespace {
/**
* Simple lookup for shortcode templates
*/
lookup(name) {
const state = this.findTemplate(name);
if (!state) {
return null;
}
return state.template;
}
/**
* Add shortcode template with validation
*/
addShortcodeTemplate(name, state) {
// Ensure it's marked as shortcode type
const shortcodeState = {
...state,
type: type_1.TemplateType.TypeShortcode
};
this.addTemplate(name, shortcodeState);
}
/**
* Get shortcode by name (alias for lookup for clarity)
*/
getShortcode(name) {
return this.lookup(name);
}
/**
* Check if shortcode exists
*/
hasShortcode(name) {
return this.hasTemplate(name);
}
/**
* Get all shortcode names
*/
getShortcodeNames() {
return this.getTemplateNames();
}
}
exports.ShortcodeTemplateNamespace = ShortcodeTemplateNamespace;
/**
* Create a new regular template namespace
*/
function newRegularTemplateNamespace() {
return new RegularTemplateNamespace();
}
/**
* Create a new partial template namespace
*/
function newPartialTemplateNamespace() {
return new PartialTemplateNamespace();
}
/**
* Create a new shortcode template namespace
*/
function newShortcodeTemplateNamespace() {
return new ShortcodeTemplateNamespace();
}
//# sourceMappingURL=namespace.js.map