directus-template-cli 0.7.0-beta.4 → 0.7.0-beta.6

package/dist/lib/utils/get-template.js

@@ -1,49 +1,47 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGithubTemplate = exports.getInteractiveLocalTemplate = exports.getLocalTemplate = exports.getCommunityTemplates = void 0;
-const tslib_1 = require("tslib");
-const giget_1 = require("giget");
-const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
-const node_path_1 = tslib_1.__importDefault(require("node:path"));
-const constants_1 = require("../constants");
-const path_1 = tslib_1.__importDefault(require("./path"));
-const read_templates_1 = require("./read-templates");
-const transform_github_url_1 = require("./transform-github-url");
-async function getCommunityTemplates() {
-    const downloadDir = (0, path_1.default)(node_path_1.default.join(__dirname, '..', 'downloads', 'official'), false);
+import { downloadTemplate } from 'giget';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path, { dirname } from 'pathe';
+import { COMMUNITY_TEMPLATE_REPO } from '../constants.js';
+import resolvePathAndCheckExistence from './path.js';
+import { readAllTemplates, readTemplate } from './read-templates.js';
+import { transformGitHubUrl } from './transform-github-url.js';
+// Create __dirname equivalent for ESM
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export async function getCommunityTemplates() {
+    const downloadDir = resolvePathAndCheckExistence(path.join(__dirname, '..', 'downloads', 'official'), false);
     if (!downloadDir) {
-        throw new Error(`Invalid download directory: ${node_path_1.default.join(__dirname, '..', 'downloads', 'official')}`);
+        throw new Error(`Invalid download directory: ${path.join(__dirname, '..', 'downloads', 'official')}`);
     }
     try {
-        const { dir } = await (0, giget_1.downloadTemplate)(constants_1.COMMUNITY_TEMPLATE_REPO.string, {
+        const { dir } = await downloadTemplate(COMMUNITY_TEMPLATE_REPO.string, {
             dir: downloadDir,
             force: true,
         });
-        return await (0, read_templates_1.readAllTemplates)(dir);
+        return await readAllTemplates(dir);
     }
     catch (error) {
         throw new Error(`Failed to download community templates: ${error}`);
     }
 }
-exports.getCommunityTemplates = getCommunityTemplates;
-async function getLocalTemplate(localTemplateDir) {
-    const resolvedDir = (0, path_1.default)(localTemplateDir);
+export async function getLocalTemplate(localTemplateDir) {
+    const resolvedDir = resolvePathAndCheckExistence(localTemplateDir);
     if (!resolvedDir) {
         throw new Error('Directory does not exist.');
     }
-    return (0, read_templates_1.readTemplate)(resolvedDir);
+    return readTemplate(resolvedDir);
 }
-exports.getLocalTemplate = getLocalTemplate;
-async function getInteractiveLocalTemplate(localTemplateDir) {
-    const resolvedDir = (0, path_1.default)(localTemplateDir);
+export async function getInteractiveLocalTemplate(localTemplateDir) {
+    const resolvedDir = resolvePathAndCheckExistence(localTemplateDir);
     if (!resolvedDir) {
         throw new Error('Directory does not exist.');
     }
-    const directTemplate = await (0, read_templates_1.readTemplate)(resolvedDir);
+    const directTemplate = await readTemplate(resolvedDir);
     if (directTemplate) {
         return [directTemplate];
     }
-    const templates = await (0, read_templates_1.readAllTemplates)(resolvedDir);
+    const templates = await readAllTemplates(resolvedDir);
     if (templates.length === 0) {
         // If no templates found, search nested directories
         const nestedTemplates = await findNestedTemplates(resolvedDir, 2);
@@ -54,16 +52,15 @@ async function getInteractiveLocalTemplate(localTemplateDir) {
     }
     return templates;
 }
-exports.getInteractiveLocalTemplate = getInteractiveLocalTemplate;
 async function findNestedTemplates(dir, depth) {
     if (depth === 0)
         return [];
     const templates = [];
-    const entries = await node_fs_1.default.promises.readdir(dir, { withFileTypes: true });
+    const entries = await fs.promises.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
         if (entry.isDirectory()) {
-            const fullPath = node_path_1.default.join(dir, entry.name);
-            const dirTemplates = await (0, read_templates_1.readAllTemplates)(fullPath);
+            const fullPath = path.join(dir, entry.name);
+            const dirTemplates = await readAllTemplates(fullPath);
             templates.push(...dirTemplates);
             if (dirTemplates.length === 0 && depth > 1) {
                 // If no templates found and we can go deeper, search subdirectories
@@ -74,26 +71,25 @@ async function findNestedTemplates(dir, depth) {
     }
     return templates;
 }
-async function getGithubTemplate(ghTemplateUrl) {
+export async function getGithubTemplate(ghTemplateUrl) {
     try {
-        const ghString = await (0, transform_github_url_1.transformGitHubUrl)(ghTemplateUrl);
-        const downloadDir = (0, path_1.default)(node_path_1.default.join(__dirname, '..', 'downloads', 'github'), false);
+        const ghString = await transformGitHubUrl(ghTemplateUrl);
+        const downloadDir = resolvePathAndCheckExistence(path.join(__dirname, '..', 'downloads', 'github'), false);
         if (!downloadDir) {
-            throw new Error(`Invalid download directory: ${node_path_1.default.join(__dirname, '..', 'downloads', 'github')}`);
+            throw new Error(`Invalid download directory: ${path.join(__dirname, '..', 'downloads', 'github')}`);
         }
-        const { dir } = await (0, giget_1.downloadTemplate)(ghString, {
+        const { dir } = await downloadTemplate(ghString, {
             dir: downloadDir,
             force: true,
             forceClean: true,
         });
-        const resolvedDir = (0, path_1.default)(dir);
+        const resolvedDir = resolvePathAndCheckExistence(dir);
         if (!resolvedDir) {
             throw new Error(`Downloaded template directory does not exist: ${dir}`);
         }
-        return (0, read_templates_1.readTemplate)(resolvedDir);
+        return readTemplate(resolvedDir);
     }
     catch (error) {
         throw new Error(`Failed to download GitHub template: ${error}`);
     }
 }
-exports.getGithubTemplate = getGithubTemplate;

package/dist/lib/utils/logger.js

@@ -1,10 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = void 0;
-const tslib_1 = require("tslib");
-const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
-const node_path_1 = tslib_1.__importDefault(require("node:path"));
+import fs from 'node:fs';
+import path from 'pathe';
 class Logger {
+    static instance;
+    logFilePath;
     constructor() {
         this.initializeLogFile();
     }
@@ -21,13 +19,13 @@ class Logger {
         this.writeToFile(logEntry);
     }
     initializeLogFile() {
-        // @ts-ignore
+        // @ts-ignore - ignore
         const timestamp = new Date().toISOString().replaceAll(/[.:]/g, '-');
-        const logDir = node_path_1.default.join(process.cwd(), '.directus-template-cli', 'logs');
-        if (!node_fs_1.default.existsSync(logDir)) {
-            node_fs_1.default.mkdirSync(logDir, { recursive: true });
+        const logDir = path.join(process.cwd(), '.directus-template-cli', 'logs');
+        if (!fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
         }
-        this.logFilePath = node_path_1.default.join(logDir, `run-${timestamp}.log`);
+        this.logFilePath = path.join(logDir, `run-${timestamp}.log`);
         // Write initial timestamp to the log file
         this.writeToFile(`Log started at ${timestamp}\n`);
     }
@@ -45,11 +43,11 @@ class Logger {
     }
     writeToFile(message) {
         try {
-            node_fs_1.default.appendFileSync(this.logFilePath, message);
+            fs.appendFileSync(this.logFilePath, message);
         }
         catch (error) {
             console.error('Error writing to log file:', error);
         }
     }
 }
-exports.logger = Logger.getInstance();
+export const logger = Logger.getInstance();

package/dist/lib/utils/open-url.js

@@ -1,19 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_child_process_1 = require("node:child_process");
-function openUrl(url) {
+import { exec } from 'node:child_process';
+export default function openUrl(url) {
     switch (process.platform) {
         case 'darwin': {
-            (0, node_child_process_1.exec)(`open ${url}`);
+            exec(`open ${url}`);
             break;
         }
         case 'win32': {
-            (0, node_child_process_1.exec)(`start ${url}`);
+            exec(`start ${url}`);
             break;
         }
         default: {
-            (0, node_child_process_1.exec)(`xdg-open ${url}`);
+            exec(`xdg-open ${url}`);
         }
     }
 }
-exports.default = openUrl;

package/dist/lib/utils/parse-github-url.d.ts

@@ -5,10 +5,15 @@ interface GitHubUrlParts {
     repo: string;
 }
 /**
-   * Parse a GitHub URL into its components.
-   * @param url - The GitHub URL to parse.
-   * @returns The parsed GitHub URL components.
-   */
+ * Parse a GitHub URL or path into its components
+ * @param url The URL or path to parse
+ * @returns The parsed components
+ */
 export declare function parseGitHubUrl(url: string): GitHubUrlParts;
-export declare function createGigetString({ owner, path, ref, repo }: GitHubUrlParts): string;
+/**
+ * Creates a giget-compatible string from GitHub URL parts
+ * @param parts The parsed GitHub URL parts
+ * @returns A string in the format 'gh:owner/repo#ref[/path]'
+ */
+export declare function createGigetString(parts: GitHubUrlParts): string;
 export {};

package/dist/lib/utils/parse-github-url.js

@@ -1,54 +1,89 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createGigetString = exports.parseGitHubUrl = void 0;
-const constants_1 = require("../constants");
+import { DEFAULT_BRANCH, DEFAULT_REPO } from '../constants.js';
 /**
-   * Parse a GitHub URL into its components.
-   * @param url - The GitHub URL to parse.
-   * @returns The parsed GitHub URL components.
-   */
-function parseGitHubUrl(url) {
-    // Handle simple template names by using default repo
-    if (!url.includes('/')) {
-        return { ...constants_1.DEFAULT_REPO, path: url };
-    }
-    // Handle different GitHub URL formats:
-    // - https://github.com/owner/repo
-    // - https://github.com/owner/repo/tree/branch
-    // - https://github.com/owner/repo/tree/branch/path
-    // - owner/repo
-    // - owner/repo/path
+ * Clean and normalize a GitHub URL
+ * Handles various formats:
+ * - Full URLs with .git
+ * - URLs with query parameters
+ * - URLs with hash fragments
+ * - URLs with branches/refs
+ * - Repository paths
+ * @param url The URL or path to clean
+ * @returns Cleaned URL without .git, queries, or hashes
+ */
+function cleanGitHubUrl(url) {
     try {
-        if (url.startsWith('https://github.com/')) {
-            url = url.replace('https://github.com/', '');
+        // If it's not a URL, return as is (might be a path)
+        if (!url.includes('://')) {
+            return url.replace(/\.git$/, '');
         }
-        const parts = url.split('/');
-        const owner = parts[0];
-        const repo = parts[1];
-        let path = '';
-        let ref;
-        if (parts.length > 2) {
-            if (parts[2] === 'tree' && parts.length > 3) {
-                ref = parts[3];
-                path = parts.slice(4).join('/');
-            }
-            else {
-                path = parts.slice(2).join('/');
+        // Parse the URL
+        const parsed = new URL(url);
+        // Remove .git suffix from pathname
+        parsed.pathname = parsed.pathname.replace(/\.git$/, '');
+        // Remove search params and hash
+        parsed.search = '';
+        parsed.hash = '';
+        return parsed.toString();
+    }
+    catch (error) {
+        // If URL parsing fails, just remove .git suffix
+        return url.replace(/\.git$/, '');
+    }
+}
+/**
+ * Parse a GitHub URL or path into its components
+ * @param url The URL or path to parse
+ * @returns The parsed components
+ */
+export function parseGitHubUrl(url) {
+    if (!url) {
+        throw new Error('URL is required');
+    }
+    // Clean the URL first
+    const cleanedUrl = cleanGitHubUrl(url);
+    // Handle full GitHub URLs
+    if (cleanedUrl.includes('github.com')) {
+        try {
+            const parsed = new URL(cleanedUrl);
+            const parts = parsed.pathname.split('/').filter(Boolean);
+            if (parts.length < 2) {
+                throw new Error('Invalid GitHub URL format');
             }
+            const [owner, repo, ...rest] = parts;
+            const path = rest.length > 0 ? rest.join('/') : undefined;
+            const ref = parsed.searchParams.get('ref') || DEFAULT_BRANCH;
+            return { owner, repo, path, ref };
+        }
+        catch (error) {
+            throw new Error(`Invalid GitHub URL: ${url}`);
         }
-        return { owner, path, ref, repo };
     }
-    catch {
-        throw new Error(`Invalid GitHub URL format: ${url}`);
+    // Handle repository paths (owner/repo format)
+    const parts = cleanedUrl.split('/').filter(Boolean);
+    if (parts.length >= 2) {
+        const [owner, repo, ...rest] = parts;
+        const path = rest.length > 0 ? rest.join('/') : undefined;
+        return { owner, repo, path, ref: DEFAULT_BRANCH };
     }
+    // Handle simple template names using DEFAULT_REPO
+    return {
+        ...DEFAULT_REPO,
+        path: cleanedUrl // The template name becomes the subpath
+    };
 }
-exports.parseGitHubUrl = parseGitHubUrl;
-function createGigetString({ owner, path, ref, repo }) {
-    let source = `github:${owner}/${repo}`;
-    if (path)
-        source += `/${path}`;
-    if (ref)
-        source += `#${ref}`;
-    return source;
+/**
+ * Creates a giget-compatible string from GitHub URL parts
+ * @param parts The parsed GitHub URL parts
+ * @returns A string in the format 'gh:owner/repo#ref[/path]'
+ */
+export function createGigetString(parts) {
+    // For the default repo case with a template name
+    if (parts.owner === DEFAULT_REPO.owner && parts.repo === DEFAULT_REPO.repo) {
+        return `gh:${parts.owner}/${parts.repo}/${parts.path}#${DEFAULT_REPO.ref}`;
+    }
+    // For other GitHub URLs
+    const base = `gh:${parts.owner}/${parts.repo}`;
+    const path = parts.path ? `/${parts.path}` : '';
+    const ref = parts.ref ? `#${parts.ref}` : '';
+    return `${base}${path}${ref}`;
 }
-exports.createGigetString = createGigetString;

package/dist/lib/utils/path.js

@@ -1,20 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
-const node_path_1 = tslib_1.__importDefault(require("node:path"));
-const node_process_1 = require("node:process");
+import fs from 'node:fs';
+import path from 'pathe';
+import { cwd } from 'node:process';
 /**
  * Resolves a given path to an absolute path and checks if it exists.
  * @param inputPath The path to resolve.
  * @param checkExistence Whether to check if the resolved path exists.
  * @returns The resolved absolute path if it exists, or null if it doesn't.
  */
-function resolvePathAndCheckExistence(inputPath, checkExistence = true) {
-    const resolvedPath = node_path_1.default.isAbsolute(inputPath) ? inputPath : node_path_1.default.resolve((0, node_process_1.cwd)(), inputPath);
-    if (!checkExistence || node_fs_1.default.existsSync(resolvedPath)) {
+export default function resolvePathAndCheckExistence(inputPath, checkExistence = true) {
+    const resolvedPath = path.isAbsolute(inputPath) ? inputPath : path.resolve(cwd(), inputPath);
+    if (!checkExistence || fs.existsSync(resolvedPath)) {
         return resolvedPath;
     }
     return null;
 }
-exports.default = resolvePathAndCheckExistence;

package/dist/lib/utils/protected-domains.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.protectedDomains = void 0;
-exports.protectedDomains = [
+export const protectedDomains = [
     'directus.pizza',
 ];

package/dist/lib/utils/read-file.js

@@ -1,16 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
-const node_path_1 = tslib_1.__importDefault(require("node:path"));
-const catch_error_1 = tslib_1.__importDefault(require("./catch-error"));
-function readFile(file, dir) {
-    const filePath = node_path_1.default.join(dir, `${file}.json`); // Use path.join for proper path resolution
-    if (!node_fs_1.default.existsSync(filePath)) {
-        (0, catch_error_1.default)(`File not found: ${filePath}`);
+import fs from 'node:fs';
+import path from 'pathe';
+import catchError from './catch-error.js';
+export default function readFile(file, dir) {
+    const filePath = path.join(dir, `${file}.json`); // Use path.join for proper path resolution
+    if (!fs.existsSync(filePath)) {
+        catchError(`File not found: ${filePath}`);
     }
-    const fileContents = node_fs_1.default.readFileSync(filePath, 'utf8');
+    const fileContents = fs.readFileSync(filePath, 'utf8');
     const obj = JSON.parse(fileContents);
     return obj;
 }
-exports.default = readFile;

package/dist/lib/utils/read-templates.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readAllTemplates = exports.readTemplate = void 0;
-const tslib_1 = require("tslib");
-const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
-const node_path_1 = tslib_1.__importDefault(require("node:path"));
-async function readTemplate(directoryPath) {
-    const packageFilePath = node_path_1.default.join(directoryPath, 'package.json');
+import fs from 'node:fs';
+import path from 'pathe';
+export async function readTemplate(directoryPath) {
+    const packageFilePath = path.join(directoryPath, 'package.json');
     try {
-        const packageData = await node_fs_1.default.promises.readFile(packageFilePath, 'utf8');
+        const packageData = await fs.promises.readFile(packageFilePath, 'utf8');
         const packageJson = JSON.parse(packageData);
         if (packageJson.templateName) {
             return {
@@ -24,13 +20,12 @@ async function readTemplate(directoryPath) {
         return null;
     }
 }
-exports.readTemplate = readTemplate;
-async function readAllTemplates(directoryPath) {
+export async function readAllTemplates(directoryPath) {
     const templates = [];
-    const files = await node_fs_1.default.promises.readdir(directoryPath);
+    const files = await fs.promises.readdir(directoryPath);
     for (const file of files) {
-        const filePath = node_path_1.default.join(directoryPath, file);
-        const stats = await node_fs_1.default.promises.stat(filePath);
+        const filePath = path.join(directoryPath, file);
+        const stats = await fs.promises.stat(filePath);
         if (stats.isDirectory()) {
             const template = await readTemplate(filePath);
             if (template) {
@@ -40,4 +35,3 @@ async function readAllTemplates(directoryPath) {
     }
     return templates;
 }
-exports.readAllTemplates = readAllTemplates;

package/dist/lib/utils/sanitize-flags.d.ts

@@ -0,0 +1,3 @@
+export declare const sanitizeFlags: (flags: Record<string, unknown>) => {
+    [k: string]: unknown;
+};

package/dist/lib/utils/sanitize-flags.js

@@ -0,0 +1,4 @@
+const SENSITIVE_FLAGS = ['userEmail', 'userPassword', 'directusToken'];
+export const sanitizeFlags = (flags) => {
+    return Object.fromEntries(Object.entries(flags).filter(([key]) => !SENSITIVE_FLAGS.includes(key)));
+};

package/dist/lib/utils/system-fields.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.systemFields = exports.directusSettingsFields = exports.directusPanelFields = exports.directusDashboardFields = exports.directusOperationFields = exports.directusFlowFields = exports.directusFolderFields = exports.directusFileFields = exports.directusRoleFields = exports.directusUserFields = void 0;
-exports.directusUserFields = [
+export const directusUserFields = [
     'id',
     'status',
     'first_name',
@@ -25,7 +22,7 @@ exports.directusUserFields = [
     'tags',
     'email_notifications',
 ];
-exports.directusRoleFields = [
+export const directusRoleFields = [
     'id',
     'name',
     'description',
@@ -36,7 +33,7 @@ exports.directusRoleFields = [
     'app_access',
     'admin_access',
 ];
-exports.directusFileFields = [
+export const directusFileFields = [
     'id',
     'storage',
     'filename_disk',
@@ -59,12 +56,12 @@ exports.directusFileFields = [
     'tags',
     'metadata',
 ];
-exports.directusFolderFields = [
+export const directusFolderFields = [
     'id',
     'name',
     'parent',
 ];
-exports.directusFlowFields = [
+export const directusFlowFields = [
     'id',
     'name',
     'icon',
@@ -78,7 +75,7 @@ exports.directusFlowFields = [
     'date_created',
     'user_created',
 ];
-exports.directusOperationFields = [
+export const directusOperationFields = [
     'id',
     'name',
     'key',
@@ -92,7 +89,7 @@ exports.directusOperationFields = [
     'date_created',
     'user_created',
 ];
-exports.directusDashboardFields = [
+export const directusDashboardFields = [
     'id',
     'name',
     'icon',
@@ -101,7 +98,7 @@ exports.directusDashboardFields = [
     'user_created',
     'color',
 ];
-exports.directusPanelFields = [
+export const directusPanelFields = [
     'id',
     'dashboard',
     'name',
@@ -118,7 +115,7 @@ exports.directusPanelFields = [
     'date_created',
     'user_created',
 ];
-exports.directusSettingsFields = [
+export const directusSettingsFields = [
     'id',
     'project_name',
     'project_url',
@@ -146,14 +143,14 @@ exports.directusSettingsFields = [
     'default_theme_dark',
     'theme_dark_overrides',
 ];
-exports.systemFields = {
-    directus_dashboards: exports.directusDashboardFields,
-    directus_files: exports.directusFileFields,
-    directus_flows: exports.directusFlowFields,
-    directus_folders: exports.directusFolderFields,
-    directus_operations: exports.directusOperationFields,
-    directus_panels: exports.directusPanelFields,
-    directus_roles: exports.directusRoleFields,
-    directus_settings: exports.directusSettingsFields,
-    directus_users: exports.directusUserFields,
+export const systemFields = {
+    directus_dashboards: directusDashboardFields,
+    directus_files: directusFileFields,
+    directus_flows: directusFlowFields,
+    directus_folders: directusFolderFields,
+    directus_operations: directusOperationFields,
+    directus_panels: directusPanelFields,
+    directus_roles: directusRoleFields,
+    directus_settings: directusSettingsFields,
+    directus_users: directusUserFields,
 };

package/dist/lib/utils/template-config.d.ts

@@ -0,0 +1,16 @@
+import type { DirectusTemplateConfig } from '../types.js';
+export interface TemplateInfo {
+    config: DirectusTemplateConfig;
+    frontendOptions: Array<{
+        id: string;
+        name: string;
+        path: string;
+    }>;
+}
+/**
+ * Read and validate the template configuration from a directory
+ * @param dir Directory containing the template
+ * @returns Template configuration and frontend options
+ * @throws Error if package.json is missing or invalid
+ */
+export declare function readTemplateConfig(dir: string): TemplateInfo | null;

package/dist/lib/utils/template-config.js

@@ -0,0 +1,34 @@
+import fs from 'node:fs';
+import path from 'pathe';
+/**
+ * Read and validate the template configuration from a directory
+ * @param dir Directory containing the template
+ * @returns Template configuration and frontend options
+ * @throws Error if package.json is missing or invalid
+ */
+export function readTemplateConfig(dir) {
+    try {
+        const packageJsonPath = path.join(dir, 'package.json');
+        if (!fs.existsSync(packageJsonPath)) {
+            return null;
+        }
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        const templateConfig = packageJson['directus:template'];
+        if (!templateConfig) {
+            return null;
+        }
+        // Convert frontends object to array of options
+        const frontendOptions = Object.entries(templateConfig.frontends || {}).map(([id, frontend]) => ({
+            id,
+            name: frontend.name,
+            path: frontend.path.replace(/^\.\//, ''), // Remove leading ./
+        }));
+        return {
+            config: templateConfig,
+            frontendOptions,
+        };
+    }
+    catch (error) {
+        return null;
+    }
+}

package/dist/lib/utils/template-defaults.d.ts

@@ -1,2 +1,2 @@
-export declare const generatePackageJsonContent: (templateName: string) => string;
+export declare function generatePackageJsonContent(templateName: string): string;
 export declare const generateReadmeContent: (templateName: string) => string;