@objectstack/metadata 1.0.4 → 1.0.6

package/dist/node-metadata-manager.js

@@ -1,98 +0,0 @@
-/**
- * Node Metadata Manager
- *
- * Extends MetadataManager with Filesystem capabilities (Watching, default loader)
- */
-import * as path from 'node:path';
-import { watch as chokidarWatch } from 'chokidar';
-import { FilesystemLoader } from './loaders/filesystem-loader.js';
-import { MetadataManager } from './metadata-manager.js';
-/**
- * Node metadata manager class
- */
-export class NodeMetadataManager extends MetadataManager {
-    constructor(config) {
-        super(config);
-        // Initialize Default Filesystem Loader if no loaders provided
-        // This logic replaces the removed logic from base class
-        if (!config.loaders || config.loaders.length === 0) {
-            const rootDir = config.rootDir || process.cwd();
-            this.registerLoader(new FilesystemLoader(rootDir, this.serializers, this.logger));
-        }
-        // Start watching if enabled
-        if (config.watch) {
-            this.startWatching();
-        }
-    }
-    /**
-     * Stop all watching
-     */
-    async stopWatching() {
-        if (this.watcher) {
-            await this.watcher.close();
-            this.watcher = undefined;
-        }
-        // Call base cleanup if any
-    }
-    /**
-     * Start watching for file changes
-     */
-    startWatching() {
-        const rootDir = this.config.rootDir || process.cwd();
-        const { ignored = ['**/node_modules/**', '**/*.test.*'], persistent = true } = this.config.watchOptions || {};
-        this.watcher = chokidarWatch(rootDir, {
-            ignored,
-            persistent,
-            ignoreInitial: true,
-        });
-        this.watcher.on('add', async (filePath) => {
-            await this.handleFileEvent('added', filePath);
-        });
-        this.watcher.on('change', async (filePath) => {
-            await this.handleFileEvent('changed', filePath);
-        });
-        this.watcher.on('unlink', async (filePath) => {
-            await this.handleFileEvent('deleted', filePath);
-        });
-        this.logger.info('File watcher started', { rootDir });
-    }
-    /**
-     * Handle file change events
-     */
-    async handleFileEvent(eventType, filePath) {
-        const rootDir = this.config.rootDir || process.cwd();
-        const relativePath = path.relative(rootDir, filePath);
-        const parts = relativePath.split(path.sep);
-        if (parts.length < 2) {
-            return; // Not a metadata file
-        }
-        const type = parts[0];
-        const fileName = parts[parts.length - 1];
-        const name = path.basename(fileName, path.extname(fileName));
-        // We can't access private watchCallbacks from parent.
-        // We need a protected method to trigger watch event or access it.
-        // OPTION: Add a method `triggerWatchEvent` to MetadataManager
-        let data = undefined;
-        if (eventType !== 'deleted') {
-            try {
-                data = await this.load(type, name, { useCache: false });
-            }
-            catch (error) {
-                this.logger.error('Failed to load changed file', undefined, {
-                    filePath,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-                return;
-            }
-        }
-        const event = {
-            type: eventType,
-            metadataType: type,
-            name,
-            path: filePath,
-            data,
-            timestamp: new Date(),
-        };
-        this.notifyWatchers(type, event);
-    }
-}

package/dist/node.d.ts

@@ -1,8 +0,0 @@
-/**
- * Node.js specific exports for @objectstack/metadata
- */
-export * from './index.js';
-export { NodeMetadataManager } from './node-metadata-manager.js';
-export { FilesystemLoader } from './loaders/filesystem-loader.js';
-export { MetadataPlugin } from './plugin.js';
-//# sourceMappingURL=node.d.ts.map

package/dist/node.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC"}

package/dist/node.js

@@ -1,7 +0,0 @@
-/**
- * Node.js specific exports for @objectstack/metadata
- */
-export * from './index.js';
-export { NodeMetadataManager } from './node-metadata-manager.js';
-export { FilesystemLoader } from './loaders/filesystem-loader.js';
-export { MetadataPlugin } from './plugin.js';

package/dist/plugin.d.ts

@@ -1,15 +0,0 @@
-import { Plugin, PluginContext } from '@objectstack/core';
-export interface MetadataPluginOptions {
-    rootDir?: string;
-    watch?: boolean;
-}
-export declare class MetadataPlugin implements Plugin {
-    name: string;
-    version: string;
-    private manager;
-    private options;
-    constructor(options?: MetadataPluginOptions);
-    init: (ctx: PluginContext) => Promise<void>;
-    start: (ctx: PluginContext) => Promise<void>;
-}
-//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAI1D,MAAM,WAAW,qBAAqB;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,qBAAa,cAAe,YAAW,MAAM;IACzC,IAAI,SAA8B;IAClC,OAAO,SAAW;IAElB,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAO,CAAC,OAAO,CAAwB;gBAE3B,OAAO,GAAE,qBAA0B;IAe/C,IAAI,GAAU,KAAK,aAAa,mBAM/B;IAED,KAAK,GAAU,KAAK,aAAa,mBAgDhC;CACJ"}

package/dist/plugin.js

@@ -1,71 +0,0 @@
-import { NodeMetadataManager } from './node-metadata-manager.js';
-import { ObjectStackDefinitionSchema } from '@objectstack/spec';
-export class MetadataPlugin {
-    constructor(options = {}) {
-        this.name = 'com.objectstack.metadata';
-        this.version = '1.0.0';
-        this.init = async (ctx) => {
-            ctx.logger.info('Initializing Metadata Manager', { root: this.options.rootDir || process.cwd() });
-            // Register Metadata Manager as a service
-            // This allows other plugins to query raw metadata or listen to changes
-            ctx.registerService('metadata', this.manager);
-        };
-        this.start = async (ctx) => {
-            ctx.logger.info('Loading metadata...');
-            // Define metadata types directly from the Protocol Definition
-            // This ensures the loader is always in sync with the Spec
-            const metadataTypes = Object.keys(ObjectStackDefinitionSchema.shape)
-                .filter(key => key !== 'manifest'); // Manifest is handled separately
-            for (const type of metadataTypes) {
-                try {
-                    // Try to load metadata of this type
-                    const items = await this.manager.loadMany(type, {
-                        recursive: true
-                    });
-                    if (items.length > 0) {
-                        ctx.logger.info(`Loaded ${items.length} ${type}`);
-                        // Helper: Register with ObjectQL Registry
-                        const ql = ctx.getService('objectql');
-                        if (ql && ql.registry) {
-                            items.forEach((item) => {
-                                // Determine key field (id or name)
-                                const keyField = item.id ? 'id' : 'name';
-                                // Map plural type to singular/registry type if needed
-                                // For now, we use the singular form for standard types: 
-                                // objects -> object, apps -> app, etc.
-                                // But Registry seems to accept arbitrary strings.
-                                // To match Protocol standard, we might want to normalize.
-                                // Let's use the directory name (plural) as the type for now,
-                                // OR map 'objects' -> 'object' specifically.
-                                let registryType = type;
-                                if (type === 'objects')
-                                    registryType = 'object';
-                                if (type === 'apps')
-                                    registryType = 'app';
-                                if (type === 'plugins')
-                                    registryType = 'plugin';
-                                if (type === 'functions')
-                                    registryType = 'function';
-                                ql.registry.registerItem(registryType, item, keyField);
-                            });
-                        }
-                    }
-                }
-                catch (e) {
-                    // Ignore missing directories or errors
-                    // ctx.logger.debug(`No metadata found for type: ${type}`);
-                }
-            }
-        };
-        this.options = {
-            watch: true,
-            ...options
-        };
-        const rootDir = this.options.rootDir || process.cwd();
-        this.manager = new NodeMetadataManager({
-            rootDir,
-            watch: this.options.watch ?? true,
-            formats: ['yaml', 'json', 'typescript', 'javascript']
-        });
-    }
-}

package/dist/serializers/json-serializer.d.ts

@@ -1,20 +0,0 @@
-/**
- * JSON Metadata Serializer
- *
- * Handles JSON format serialization and deserialization
- */
-import type { z } from 'zod';
-import type { MetadataFormat } from '@objectstack/spec/system';
-import type { MetadataSerializer, SerializeOptions } from './serializer-interface.js';
-export declare class JSONSerializer implements MetadataSerializer {
-    serialize<T>(item: T, options?: SerializeOptions): string;
-    deserialize<T>(content: string, schema?: z.ZodSchema): T;
-    getExtension(): string;
-    canHandle(format: MetadataFormat): boolean;
-    getFormat(): MetadataFormat;
-    /**
-     * Recursively sort object keys
-     */
-    private sortObjectKeys;
-}
-//# sourceMappingURL=json-serializer.d.ts.map

package/dist/serializers/json-serializer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"json-serializer.d.ts","sourceRoot":"","sources":["../../src/serializers/json-serializer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAEtF,qBAAa,cAAe,YAAW,kBAAkB;IACvD,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM;IAgBzD,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,GAAG,CAAC;IAUxD,YAAY,IAAI,MAAM;IAItB,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO;IAI1C,SAAS,IAAI,cAAc;IAI3B;;OAEG;IACH,OAAO,CAAC,cAAc;CAkBvB"}

package/dist/serializers/json-serializer.js

@@ -1,53 +0,0 @@
-/**
- * JSON Metadata Serializer
- *
- * Handles JSON format serialization and deserialization
- */
-export class JSONSerializer {
-    serialize(item, options) {
-        const { prettify = true, indent = 2, sortKeys = false } = options || {};
-        if (sortKeys) {
-            // Sort keys recursively
-            const sorted = this.sortObjectKeys(item);
-            return prettify
-                ? JSON.stringify(sorted, null, indent)
-                : JSON.stringify(sorted);
-        }
-        return prettify
-            ? JSON.stringify(item, null, indent)
-            : JSON.stringify(item);
-    }
-    deserialize(content, schema) {
-        const parsed = JSON.parse(content);
-        if (schema) {
-            return schema.parse(parsed);
-        }
-        return parsed;
-    }
-    getExtension() {
-        return '.json';
-    }
-    canHandle(format) {
-        return format === 'json';
-    }
-    getFormat() {
-        return 'json';
-    }
-    /**
-     * Recursively sort object keys
-     */
-    sortObjectKeys(obj) {
-        if (obj === null || typeof obj !== 'object') {
-            return obj;
-        }
-        if (Array.isArray(obj)) {
-            return obj.map(item => this.sortObjectKeys(item));
-        }
-        const sorted = {};
-        const keys = Object.keys(obj).sort();
-        for (const key of keys) {
-            sorted[key] = this.sortObjectKeys(obj[key]);
-        }
-        return sorted;
-    }
-}

package/dist/serializers/serializer-interface.d.ts

@@ -1,57 +0,0 @@
-/**
- * Metadata Serializer Interface
- *
- * Defines the contract for serializing/deserializing metadata
- */
-import type { z } from 'zod';
-import type { MetadataFormat } from '@objectstack/spec/system';
-/**
- * Serialization options
- */
-export interface SerializeOptions {
-    /** Prettify output (formatted with indentation) */
-    prettify?: boolean;
-    /** Indentation size (spaces) */
-    indent?: number;
-    /** Sort object keys alphabetically */
-    sortKeys?: boolean;
-    /** Include default values in output */
-    includeDefaults?: boolean;
-}
-/**
- * Abstract interface for metadata serializers
- * Implementations handle different formats (JSON, YAML, TypeScript, etc.)
- */
-export interface MetadataSerializer {
-    /**
-     * Serialize object to string
-     * @param item The item to serialize
-     * @param options Serialization options
-     * @returns Serialized string
-     */
-    serialize<T>(item: T, options?: SerializeOptions): string;
-    /**
-     * Deserialize string to object
-     * @param content The content to deserialize
-     * @param schema Optional Zod schema for validation
-     * @returns Deserialized object
-     */
-    deserialize<T>(content: string, schema?: z.ZodSchema): T;
-    /**
-     * Get file extension for this format
-     * @returns File extension (e.g., '.json', '.yaml')
-     */
-    getExtension(): string;
-    /**
-     * Check if this serializer can handle the format
-     * @param format The format to check
-     * @returns True if can handle
-     */
-    canHandle(format: MetadataFormat): boolean;
-    /**
-     * Get the format this serializer handles
-     * @returns The metadata format
-     */
-    getFormat(): MetadataFormat;
-}
-//# sourceMappingURL=serializer-interface.d.ts.map

package/dist/serializers/serializer-interface.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serializer-interface.d.ts","sourceRoot":"","sources":["../../src/serializers/serializer-interface.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,mDAAmD;IACnD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gCAAgC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,sCAAsC;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,uCAAuC;IACvC,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;OAKG;IACH,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAAC;IAE1D;;;;;OAKG;IACH,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,GAAG,CAAC,CAAC;IAEzD;;;OAGG;IACH,YAAY,IAAI,MAAM,CAAC;IAEvB;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC;IAE3C;;;OAGG;IACH,SAAS,IAAI,cAAc,CAAC;CAC7B"}

package/dist/serializers/serializer-interface.js

@@ -1,6 +0,0 @@
-/**
- * Metadata Serializer Interface
- *
- * Defines the contract for serializing/deserializing metadata
- */
-export {};

package/dist/serializers/serializers.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=serializers.test.d.ts.map

package/dist/serializers/serializers.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serializers.test.d.ts","sourceRoot":"","sources":["../../src/serializers/serializers.test.ts"],"names":[],"mappings":""}

package/dist/serializers/serializers.test.js

@@ -1,62 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { JSONSerializer } from '../serializers/json-serializer';
-import { YAMLSerializer } from '../serializers/yaml-serializer';
-import { TypeScriptSerializer } from '../serializers/typescript-serializer';
-describe('Serializers', () => {
-    describe('JSONSerializer', () => {
-        const serializer = new JSONSerializer();
-        it('should serialize to JSON', () => {
-            const data = { name: 'test', value: 42 };
-            const result = serializer.serialize(data);
-            expect(result).toContain('"name"');
-            expect(result).toContain('"test"');
-        });
-        it('should deserialize from JSON', () => {
-            const json = '{"name":"test","value":42}';
-            const result = serializer.deserialize(json);
-            expect(result).toEqual({ name: 'test', value: 42 });
-        });
-        it('should prettify JSON', () => {
-            const data = { name: 'test' };
-            const result = serializer.serialize(data, { prettify: true, indent: 2 });
-            expect(result).toContain('\n');
-            expect(result).toContain('  ');
-        });
-        it('should sort keys', () => {
-            const data = { zebra: 1, apple: 2, banana: 3 };
-            const result = serializer.serialize(data, { sortKeys: true });
-            const keys = Object.keys(JSON.parse(result));
-            expect(keys).toEqual(['apple', 'banana', 'zebra']);
-        });
-    });
-    describe('YAMLSerializer', () => {
-        const serializer = new YAMLSerializer();
-        it('should serialize to YAML', () => {
-            const data = { name: 'test', value: 42 };
-            const result = serializer.serialize(data);
-            expect(result).toContain('name: test');
-            expect(result).toContain('value: 42');
-        });
-        it('should deserialize from YAML', () => {
-            const yaml = 'name: test\nvalue: 42';
-            const result = serializer.deserialize(yaml);
-            expect(result).toEqual({ name: 'test', value: 42 });
-        });
-    });
-    describe('TypeScriptSerializer', () => {
-        const serializer = new TypeScriptSerializer('typescript');
-        it('should serialize to TypeScript module', () => {
-            const data = { name: 'test', value: 42 };
-            const result = serializer.serialize(data);
-            expect(result).toContain('import type');
-            expect(result).toContain('export const metadata');
-            expect(result).toContain('export default metadata');
-        });
-        it('should get correct extension', () => {
-            const ts = new TypeScriptSerializer('typescript');
-            expect(ts.getExtension()).toBe('.ts');
-            const js = new TypeScriptSerializer('javascript');
-            expect(js.getExtension()).toBe('.js');
-        });
-    });
-});

package/dist/serializers/typescript-serializer.d.ts

@@ -1,18 +0,0 @@
-/**
- * TypeScript/JavaScript Metadata Serializer
- *
- * Handles TypeScript/JavaScript module format serialization and deserialization
- */
-import type { z } from 'zod';
-import type { MetadataFormat } from '@objectstack/spec/system';
-import type { MetadataSerializer, SerializeOptions } from './serializer-interface.js';
-export declare class TypeScriptSerializer implements MetadataSerializer {
-    private format;
-    constructor(format?: 'typescript' | 'javascript');
-    serialize<T>(item: T, options?: SerializeOptions): string;
-    deserialize<T>(content: string, schema?: z.ZodSchema): T;
-    getExtension(): string;
-    canHandle(format: MetadataFormat): boolean;
-    getFormat(): MetadataFormat;
-}
-//# sourceMappingURL=typescript-serializer.d.ts.map

package/dist/serializers/typescript-serializer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"typescript-serializer.d.ts","sourceRoot":"","sources":["../../src/serializers/typescript-serializer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAEtF,qBAAa,oBAAqB,YAAW,kBAAkB;IACjD,OAAO,CAAC,MAAM;gBAAN,MAAM,GAAE,YAAY,GAAG,YAA2B;IAEtE,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM;IAezD,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,GAAG,CAAC;IAqFxD,YAAY,IAAI,MAAM;IAItB,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO;IAI1C,SAAS,IAAI,cAAc;CAG5B"}

package/dist/serializers/typescript-serializer.js

@@ -1,103 +0,0 @@
-/**
- * TypeScript/JavaScript Metadata Serializer
- *
- * Handles TypeScript/JavaScript module format serialization and deserialization
- */
-export class TypeScriptSerializer {
-    constructor(format = 'typescript') {
-        this.format = format;
-    }
-    serialize(item, options) {
-        const { prettify = true, indent = 2 } = options || {};
-        const jsonStr = JSON.stringify(item, null, prettify ? indent : 0);
-        if (this.format === 'typescript') {
-            return `import type { ServiceObject } from '@objectstack/spec/data';\n\n` +
-                `export const metadata: ServiceObject = ${jsonStr};\n\n` +
-                `export default metadata;\n`;
-        }
-        else {
-            return `export const metadata = ${jsonStr};\n\n` +
-                `export default metadata;\n`;
-        }
-    }
-    deserialize(content, schema) {
-        // For TypeScript/JavaScript files, we need to extract the exported object
-        // Note: This is a simplified parser that works with JSON-like object literals
-        // For complex TypeScript with nested objects, consider using a proper TypeScript parser
-        // Try to find the object literal in various export patterns
-        // Pattern 1: export const metadata = {...};
-        let objectStart = content.indexOf('export const');
-        if (objectStart === -1) {
-            // Pattern 2: export default {...};
-            objectStart = content.indexOf('export default');
-        }
-        if (objectStart === -1) {
-            throw new Error('Could not parse TypeScript/JavaScript module. ' +
-                'Expected export pattern: "export const metadata = {...};" or "export default {...};"');
-        }
-        // Find the first opening brace after the export statement
-        const braceStart = content.indexOf('{', objectStart);
-        if (braceStart === -1) {
-            throw new Error('Could not find object literal in export statement');
-        }
-        // Find the matching closing brace by counting braces
-        // Handle string literals to avoid counting braces inside strings
-        let braceCount = 0;
-        let braceEnd = -1;
-        let inString = false;
-        let stringChar = '';
-        for (let i = braceStart; i < content.length; i++) {
-            const char = content[i];
-            const prevChar = i > 0 ? content[i - 1] : '';
-            // Track string literals (simple handling of " and ')
-            if ((char === '"' || char === "'") && prevChar !== '\\') {
-                if (!inString) {
-                    inString = true;
-                    stringChar = char;
-                }
-                else if (char === stringChar) {
-                    inString = false;
-                    stringChar = '';
-                }
-            }
-            // Count braces only when not inside strings
-            if (!inString) {
-                if (char === '{')
-                    braceCount++;
-                if (char === '}') {
-                    braceCount--;
-                    if (braceCount === 0) {
-                        braceEnd = i;
-                        break;
-                    }
-                }
-            }
-        }
-        if (braceEnd === -1) {
-            throw new Error('Could not find matching closing brace for object literal');
-        }
-        // Extract the object literal
-        const objectLiteral = content.substring(braceStart, braceEnd + 1);
-        try {
-            // Parse as JSON
-            const parsed = JSON.parse(objectLiteral);
-            if (schema) {
-                return schema.parse(parsed);
-            }
-            return parsed;
-        }
-        catch (error) {
-            throw new Error(`Failed to parse object literal as JSON: ${error instanceof Error ? error.message : String(error)}. ` +
-                'Make sure the TypeScript/JavaScript object uses JSON-compatible syntax (no functions, comments, or trailing commas).');
-        }
-    }
-    getExtension() {
-        return this.format === 'typescript' ? '.ts' : '.js';
-    }
-    canHandle(format) {
-        return format === 'typescript' || format === 'javascript';
-    }
-    getFormat() {
-        return this.format;
-    }
-}

package/dist/serializers/yaml-serializer.d.ts

@@ -1,16 +0,0 @@
-/**
- * YAML Metadata Serializer
- *
- * Handles YAML format serialization and deserialization
- */
-import type { z } from 'zod';
-import type { MetadataFormat } from '@objectstack/spec/system';
-import type { MetadataSerializer, SerializeOptions } from './serializer-interface.js';
-export declare class YAMLSerializer implements MetadataSerializer {
-    serialize<T>(item: T, options?: SerializeOptions): string;
-    deserialize<T>(content: string, schema?: z.ZodSchema): T;
-    getExtension(): string;
-    canHandle(format: MetadataFormat): boolean;
-    getFormat(): MetadataFormat;
-}
-//# sourceMappingURL=yaml-serializer.d.ts.map

package/dist/serializers/yaml-serializer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"yaml-serializer.d.ts","sourceRoot":"","sources":["../../src/serializers/yaml-serializer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAEtF,qBAAa,cAAe,YAAW,kBAAkB;IACvD,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM;IAWzD,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,SAAS,GAAG,CAAC;IAYxD,YAAY,IAAI,MAAM;IAItB,SAAS,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO;IAI1C,SAAS,IAAI,cAAc;CAG5B"}

package/dist/serializers/yaml-serializer.js

@@ -1,35 +0,0 @@
-/**
- * YAML Metadata Serializer
- *
- * Handles YAML format serialization and deserialization
- */
-import * as yaml from 'js-yaml';
-export class YAMLSerializer {
-    serialize(item, options) {
-        const { indent = 2, sortKeys = false } = options || {};
-        return yaml.dump(item, {
-            indent,
-            sortKeys,
-            lineWidth: -1, // Disable line wrapping
-            noRefs: true, // Disable YAML references
-        });
-    }
-    deserialize(content, schema) {
-        // Use JSON_SCHEMA to prevent arbitrary code execution
-        // This restricts YAML to JSON-compatible types only
-        const parsed = yaml.load(content, { schema: yaml.JSON_SCHEMA });
-        if (schema) {
-            return schema.parse(parsed);
-        }
-        return parsed;
-    }
-    getExtension() {
-        return '.yaml';
-    }
-    canHandle(format) {
-        return format === 'yaml';
-    }
-    getFormat() {
-        return 'yaml';
-    }
-}