eventmodeler 0.5.0 → 0.6.1

package/dist/slices/open-app/index.d.ts

@@ -1 +0,0 @@
-export declare function openApp(): void;

package/dist/slices/open-app/index.js

@@ -1,36 +0,0 @@
-import { exec } from 'node:child_process';
-import { platform } from 'node:os';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-const APP_URL = 'https://www.eventmodeler.com';
-function getOpenCommand() {
-    switch (platform()) {
-        case 'darwin':
-            return 'open';
-        case 'win32':
-            return 'start';
-        default:
-            return 'xdg-open';
-    }
-}
-function findLocalEventModel() {
-    const files = fs.readdirSync(process.cwd());
-    const eventModelFiles = files.filter(f => f.endsWith('.eventmodel'));
-    if (eventModelFiles.length === 1) {
-        return path.join(process.cwd(), eventModelFiles[0]);
-    }
-    return null;
-}
-export function openApp() {
-    const command = getOpenCommand();
-    const localFile = findLocalEventModel();
-    console.log(`Opening ${APP_URL}...`);
-    if (localFile) {
-        console.log(`Then open: ${localFile}`);
-    }
-    exec(`${command} ${APP_URL}`, (error) => {
-        if (error) {
-            console.error(`Could not open browser. Please visit: ${APP_URL}`);
-        }
-    });
-}

package/dist/slices/remove-field/index.d.ts

@@ -1,8 +0,0 @@
-import type { EventModel } from '../../types.js';
-export declare function removeField(model: EventModel, filePath: string, options: {
-    command?: string;
-    event?: string;
-    readModel?: string;
-    screen?: string;
-    processor?: string;
-}, fieldName: string): void;

package/dist/slices/remove-field/index.js

@@ -1,167 +0,0 @@
-import { appendEvent } from '../../lib/file-loader.js';
-import { findElementOrExit, excludeLinkedCopies } from '../../lib/element-lookup.js';
-export function removeField(model, filePath, options, fieldName) {
-    // Determine which entity type
-    const entityCount = [options.command, options.event, options.readModel, options.screen, options.processor].filter(Boolean).length;
-    if (entityCount === 0) {
-        console.error('Error: Must specify one of --command, --event, --read-model, --screen, or --processor');
-        process.exit(1);
-    }
-    if (entityCount > 1) {
-        console.error('Error: Can only specify one of --command, --event, --read-model, --screen, or --processor');
-        process.exit(1);
-    }
-    if (options.command) {
-        removeFieldFromCommand(model, filePath, options.command, fieldName);
-    }
-    else if (options.event) {
-        removeFieldFromEvent(model, filePath, options.event, fieldName);
-    }
-    else if (options.readModel) {
-        removeFieldFromReadModel(model, filePath, options.readModel, fieldName);
-    }
-    else if (options.screen) {
-        removeFieldFromScreen(model, filePath, options.screen, fieldName);
-    }
-    else if (options.processor) {
-        removeFieldFromProcessor(model, filePath, options.processor, fieldName);
-    }
-}
-function removeFieldFromCommand(model, filePath, commandName, fieldName) {
-    const command = findElementOrExit(model.commands, commandName, 'command');
-    const fieldNameLower = fieldName.toLowerCase();
-    const field = command.fields.find(f => f.name.toLowerCase() === fieldNameLower);
-    if (!field) {
-        console.error(`Error: Field "${fieldName}" not found on command "${command.name}"`);
-        if (command.fields.length > 0) {
-            console.error('Available fields:');
-            for (const f of command.fields) {
-                console.error(`  - ${f.name} (${f.fieldType})`);
-            }
-        }
-        else {
-            console.error('This command has no fields.');
-        }
-        process.exit(1);
-    }
-    appendEvent(filePath, {
-        type: 'CommandFieldRemoved',
-        data: {
-            commandStickyId: command.id,
-            fieldId: field.id,
-            timestamp: Date.now(),
-        },
-    });
-    console.log(`Removed field "${field.name}" from command "${command.name}"`);
-}
-function removeFieldFromEvent(model, filePath, eventName, fieldName) {
-    // Exclude linked copies - they share fields with their canonical original
-    const event = findElementOrExit(excludeLinkedCopies(model.events), eventName, 'event');
-    const fieldNameLower = fieldName.toLowerCase();
-    const field = event.fields.find(f => f.name.toLowerCase() === fieldNameLower);
-    if (!field) {
-        console.error(`Error: Field "${fieldName}" not found on event "${event.name}"`);
-        if (event.fields.length > 0) {
-            console.error('Available fields:');
-            for (const f of event.fields) {
-                console.error(`  - ${f.name} (${f.fieldType})`);
-            }
-        }
-        else {
-            console.error('This event has no fields.');
-        }
-        process.exit(1);
-    }
-    appendEvent(filePath, {
-        type: 'EventFieldRemoved',
-        data: {
-            eventStickyId: event.id,
-            fieldId: field.id,
-            timestamp: Date.now(),
-        },
-    });
-    console.log(`Removed field "${field.name}" from event "${event.name}"`);
-}
-function removeFieldFromReadModel(model, filePath, readModelName, fieldName) {
-    // Exclude linked copies - they share fields with their canonical original
-    const readModel = findElementOrExit(excludeLinkedCopies(model.readModels), readModelName, 'read model');
-    const fieldNameLower = fieldName.toLowerCase();
-    const field = readModel.fields.find(f => f.name.toLowerCase() === fieldNameLower);
-    if (!field) {
-        console.error(`Error: Field "${fieldName}" not found on read model "${readModel.name}"`);
-        if (readModel.fields.length > 0) {
-            console.error('Available fields:');
-            for (const f of readModel.fields) {
-                console.error(`  - ${f.name} (${f.fieldType})`);
-            }
-        }
-        else {
-            console.error('This read model has no fields.');
-        }
-        process.exit(1);
-    }
-    appendEvent(filePath, {
-        type: 'ReadModelFieldRemoved',
-        data: {
-            readModelStickyId: readModel.id,
-            fieldId: field.id,
-            timestamp: Date.now(),
-        },
-    });
-    console.log(`Removed field "${field.name}" from read model "${readModel.name}"`);
-}
-function removeFieldFromScreen(model, filePath, screenName, fieldName) {
-    // Exclude linked copies - they share fields with their canonical original
-    const screen = findElementOrExit(excludeLinkedCopies(model.screens), screenName, 'screen');
-    const fieldNameLower = fieldName.toLowerCase();
-    const field = screen.fields.find(f => f.name.toLowerCase() === fieldNameLower);
-    if (!field) {
-        console.error(`Error: Field "${fieldName}" not found on screen "${screen.name}"`);
-        if (screen.fields.length > 0) {
-            console.error('Available fields:');
-            for (const f of screen.fields) {
-                console.error(`  - ${f.name} (${f.fieldType})`);
-            }
-        }
-        else {
-            console.error('This screen has no fields.');
-        }
-        process.exit(1);
-    }
-    appendEvent(filePath, {
-        type: 'ScreenFieldRemoved',
-        data: {
-            screenId: screen.id,
-            fieldId: field.id,
-            timestamp: Date.now(),
-        },
-    });
-    console.log(`Removed field "${field.name}" from screen "${screen.name}"`);
-}
-function removeFieldFromProcessor(model, filePath, processorName, fieldName) {
-    const processor = findElementOrExit(model.processors, processorName, 'processor');
-    const fieldNameLower = fieldName.toLowerCase();
-    const field = processor.fields.find(f => f.name.toLowerCase() === fieldNameLower);
-    if (!field) {
-        console.error(`Error: Field "${fieldName}" not found on processor "${processor.name}"`);
-        if (processor.fields.length > 0) {
-            console.error('Available fields:');
-            for (const f of processor.fields) {
-                console.error(`  - ${f.name} (${f.fieldType})`);
-            }
-        }
-        else {
-            console.error('This processor has no fields.');
-        }
-        process.exit(1);
-    }
-    appendEvent(filePath, {
-        type: 'ProcessorFieldRemoved',
-        data: {
-            processorId: processor.id,
-            fieldId: field.id,
-            timestamp: Date.now(),
-        },
-    });
-    console.log(`Removed field "${field.name}" from processor "${processor.name}"`);
-}

package/dist/slices/remove-scenario/index.d.ts

@@ -1,2 +0,0 @@
-import type { EventModel } from '../../types.js';
-export declare function removeScenario(model: EventModel, filePath: string, scenarioName: string, sliceName?: string): void;

package/dist/slices/remove-scenario/index.js

@@ -1,77 +0,0 @@
-import { appendEvent } from '../../lib/file-loader.js';
-import { findElement, formatElementWithId } from '../../lib/element-lookup.js';
-export function removeScenario(model, filePath, scenarioName, sliceName) {
-    // Check for UUID lookup
-    if (scenarioName.startsWith('id:')) {
-        const idSearch = scenarioName.slice(3).toLowerCase();
-        const scenario = [...model.scenarios.values()].find(s => s.id.toLowerCase().startsWith(idSearch));
-        if (!scenario) {
-            console.error(`Error: Scenario not found with ID starting with: "${idSearch}"`);
-            console.error('Available scenarios:');
-            for (const s of model.scenarios.values()) {
-                const slice = model.slices.get(s.sliceId);
-                console.error(`  - "${s.name}" (id: ${s.id.slice(0, 8)}) (in slice "${slice?.name ?? 'unknown'}")`);
-            }
-            process.exit(1);
-        }
-        const slice = model.slices.get(scenario.sliceId);
-        appendEvent(filePath, {
-            type: 'ScenarioRemoved',
-            data: {
-                scenarioId: scenario.id,
-                timestamp: Date.now(),
-            },
-        });
-        console.log(`Removed scenario "${scenario.name}" from slice "${slice?.name ?? 'unknown'}"`);
-        return;
-    }
-    // Case-insensitive exact name match
-    const scenarioNameLower = scenarioName.toLowerCase();
-    let matchingScenarios = [...model.scenarios.values()].filter(s => s.name.toLowerCase() === scenarioNameLower);
-    // If slice name provided, filter to that slice using exact match
-    if (sliceName && matchingScenarios.length > 0) {
-        const sliceResult = findElement(model.slices, sliceName);
-        if (sliceResult.success) {
-            matchingScenarios = matchingScenarios.filter(s => s.sliceId === sliceResult.element.id);
-        }
-        else if (sliceResult.error === 'ambiguous') {
-            console.error(`Error: Multiple slices found with name "${sliceName}"`);
-            console.error('Please specify using the slice ID:');
-            for (const s of sliceResult.matches) {
-                console.error(`  - ${formatElementWithId(s, false)}`);
-            }
-            process.exit(1);
-        }
-        // If slice not found, just proceed without filtering
-    }
-    if (matchingScenarios.length === 0) {
-        console.error(`Error: Scenario not found: "${scenarioName}"`);
-        console.error('Available scenarios:');
-        for (const s of model.scenarios.values()) {
-            const slice = model.slices.get(s.sliceId);
-            console.error(`  - "${s.name}" (id: ${s.id.slice(0, 8)}) (in slice "${slice?.name ?? 'unknown'}")`);
-        }
-        process.exit(1);
-    }
-    if (matchingScenarios.length > 1) {
-        console.error(`Error: Multiple scenarios found with name "${scenarioName}"`);
-        console.error('Please specify using the scenario ID or --slice to disambiguate:');
-        for (const s of matchingScenarios) {
-            const slice = model.slices.get(s.sliceId);
-            console.error(`  - "${s.name}" (id: ${s.id.slice(0, 8)}) (in slice "${slice?.name ?? 'unknown'}")`);
-        }
-        console.error('');
-        console.error(`Usage: eventmodeler remove scenario "id:${matchingScenarios[0].id.slice(0, 8)}"`);
-        process.exit(1);
-    }
-    const scenario = matchingScenarios[0];
-    const slice = model.slices.get(scenario.sliceId);
-    appendEvent(filePath, {
-        type: 'ScenarioRemoved',
-        data: {
-            scenarioId: scenario.id,
-            timestamp: Date.now(),
-        },
-    });
-    console.log(`Removed scenario "${scenario.name}" from slice "${slice?.name ?? 'unknown'}"`);
-}

package/dist/slices/search/index.d.ts

@@ -1,3 +0,0 @@
-import type { EventModel } from '../../types.js';
-import { type OutputFormat } from '../../lib/format.js';
-export declare function search(model: EventModel, term: string, format: OutputFormat): void;

package/dist/slices/search/index.js

@@ -1,302 +0,0 @@
-import { escapeXml, outputJson } from '../../lib/format.js';
-function isInSlice(slice, pos, width, height) {
-    const centerX = pos.x + width / 2;
-    const centerY = pos.y + height / 2;
-    return (centerX >= slice.position.x &&
-        centerX <= slice.position.x + slice.size.width &&
-        centerY >= slice.position.y &&
-        centerY <= slice.position.y + slice.size.height);
-}
-function findSlicesContaining(model, pos, width, height) {
-    return [...model.slices.values()].filter(slice => isInSlice(slice, pos, width, height));
-}
-export function search(model, term, format) {
-    const termLower = term.toLowerCase();
-    const xmlResults = [];
-    const jsonResults = [];
-    // Search commands
-    for (const cmd of model.commands.values()) {
-        if (cmd.name.toLowerCase().includes(termLower)) {
-            const slices = findSlicesContaining(model, cmd.position, cmd.width, cmd.height);
-            const incomingFlows = [...model.flows.values()].filter(f => f.targetId === cmd.id);
-            const outgoingFlows = [...model.flows.values()].filter(f => f.sourceId === cmd.id);
-            // JSON result
-            const jsonResult = { type: 'command', name: cmd.name, fields: cmd.fields.length };
-            if (slices.length > 0) {
-                jsonResult.inSlices = slices.map(s => ({ name: s.name, status: s.status }));
-            }
-            const triggeredBy = [];
-            for (const flow of incomingFlows) {
-                const screen = model.screens.get(flow.sourceId);
-                const processor = model.processors.get(flow.sourceId);
-                if (screen)
-                    triggeredBy.push(screen.name);
-                if (processor)
-                    triggeredBy.push(processor.name);
-            }
-            if (triggeredBy.length > 0)
-                jsonResult.triggeredBy = triggeredBy;
-            const produces = [];
-            for (const flow of outgoingFlows) {
-                const evt = model.events.get(flow.targetId);
-                if (evt)
-                    produces.push(evt.name);
-            }
-            if (produces.length > 0)
-                jsonResult.produces = produces;
-            jsonResults.push(jsonResult);
-            // XML result
-            let xml = `  <command name="${escapeXml(cmd.name)}" fields="${cmd.fields.length}">\n`;
-            if (slices.length > 0) {
-                xml += '    <in-slices>\n';
-                for (const slice of slices) {
-                    xml += `      <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>\n`;
-                }
-                xml += '    </in-slices>\n';
-            }
-            if (incomingFlows.length > 0) {
-                xml += '    <triggered-by>\n';
-                for (const flow of incomingFlows) {
-                    const screen = model.screens.get(flow.sourceId);
-                    const processor = model.processors.get(flow.sourceId);
-                    if (screen)
-                        xml += `      <screen name="${escapeXml(screen.name)}"/>\n`;
-                    if (processor)
-                        xml += `      <processor name="${escapeXml(processor.name)}"/>\n`;
-                }
-                xml += '    </triggered-by>\n';
-            }
-            if (outgoingFlows.length > 0) {
-                xml += '    <produces>\n';
-                for (const flow of outgoingFlows) {
-                    const evt = model.events.get(flow.targetId);
-                    if (evt)
-                        xml += `      <event name="${escapeXml(evt.name)}"/>\n`;
-                }
-                xml += '    </produces>\n';
-            }
-            xml += '  </command>';
-            xmlResults.push(xml);
-        }
-    }
-    // Search events
-    for (const evt of model.events.values()) {
-        if (evt.name.toLowerCase().includes(termLower)) {
-            const slices = findSlicesContaining(model, evt.position, evt.width, evt.height);
-            const incomingFlows = [...model.flows.values()].filter(f => f.targetId === evt.id);
-            const outgoingFlows = [...model.flows.values()].filter(f => f.sourceId === evt.id);
-            // JSON result
-            const jsonResult = { type: 'event', name: evt.name, fields: evt.fields.length };
-            if (slices.length > 0) {
-                jsonResult.inSlices = slices.map(s => ({ name: s.name, status: s.status }));
-            }
-            const producedBy = [];
-            for (const flow of incomingFlows) {
-                const cmd = model.commands.get(flow.sourceId);
-                if (cmd)
-                    producedBy.push(cmd.name);
-            }
-            if (producedBy.length > 0)
-                jsonResult.producedBy = producedBy;
-            const consumedBy = [];
-            for (const flow of outgoingFlows) {
-                const rm = model.readModels.get(flow.targetId);
-                if (rm)
-                    consumedBy.push(rm.name);
-            }
-            if (consumedBy.length > 0)
-                jsonResult.consumedBy = consumedBy;
-            jsonResults.push(jsonResult);
-            // XML result
-            let xml = `  <event name="${escapeXml(evt.name)}" fields="${evt.fields.length}">\n`;
-            if (slices.length > 0) {
-                xml += '    <in-slices>\n';
-                for (const slice of slices) {
-                    xml += `      <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>\n`;
-                }
-                xml += '    </in-slices>\n';
-            }
-            if (incomingFlows.length > 0) {
-                xml += '    <produced-by>\n';
-                for (const flow of incomingFlows) {
-                    const cmd = model.commands.get(flow.sourceId);
-                    if (cmd)
-                        xml += `      <command name="${escapeXml(cmd.name)}"/>\n`;
-                }
-                xml += '    </produced-by>\n';
-            }
-            if (outgoingFlows.length > 0) {
-                xml += '    <consumed-by>\n';
-                for (const flow of outgoingFlows) {
-                    const rm = model.readModels.get(flow.targetId);
-                    if (rm)
-                        xml += `      <read-model name="${escapeXml(rm.name)}"/>\n`;
-                }
-                xml += '    </consumed-by>\n';
-            }
-            xml += '  </event>';
-            xmlResults.push(xml);
-        }
-    }
-    // Search read models
-    for (const rm of model.readModels.values()) {
-        if (rm.name.toLowerCase().includes(termLower)) {
-            const slices = findSlicesContaining(model, rm.position, rm.width, rm.height);
-            // JSON result
-            const jsonResult = { type: 'read-model', name: rm.name, fields: rm.fields.length };
-            if (slices.length > 0) {
-                jsonResult.inSlices = slices.map(s => ({ name: s.name, status: s.status }));
-            }
-            jsonResults.push(jsonResult);
-            // XML result
-            let xml = `  <read-model name="${escapeXml(rm.name)}" fields="${rm.fields.length}">\n`;
-            if (slices.length > 0) {
-                xml += '    <in-slices>\n';
-                for (const slice of slices) {
-                    xml += `      <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>\n`;
-                }
-                xml += '    </in-slices>\n';
-            }
-            xml += '  </read-model>';
-            xmlResults.push(xml);
-        }
-    }
-    // Search screens
-    for (const scr of model.screens.values()) {
-        if (scr.name.toLowerCase().includes(termLower)) {
-            const slices = findSlicesContaining(model, scr.position, scr.width, scr.height);
-            // JSON result
-            const jsonResult = { type: 'screen', name: scr.name, fields: scr.fields.length };
-            if (slices.length > 0) {
-                jsonResult.inSlices = slices.map(s => ({ name: s.name, status: s.status }));
-            }
-            jsonResults.push(jsonResult);
-            // XML result
-            let xml = `  <screen name="${escapeXml(scr.name)}" fields="${scr.fields.length}">\n`;
-            if (slices.length > 0) {
-                xml += '    <in-slices>\n';
-                for (const slice of slices) {
-                    xml += `      <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>\n`;
-                }
-                xml += '    </in-slices>\n';
-            }
-            xml += '  </screen>';
-            xmlResults.push(xml);
-        }
-    }
-    // Search processors
-    for (const proc of model.processors.values()) {
-        if (proc.name.toLowerCase().includes(termLower)) {
-            const slices = findSlicesContaining(model, proc.position, proc.width, proc.height);
-            // JSON result
-            const jsonResult = { type: 'processor', name: proc.name, fields: proc.fields.length };
-            if (slices.length > 0) {
-                jsonResult.inSlices = slices.map(s => ({ name: s.name, status: s.status }));
-            }
-            jsonResults.push(jsonResult);
-            // XML result
-            let xml = `  <processor name="${escapeXml(proc.name)}" fields="${proc.fields.length}">\n`;
-            if (slices.length > 0) {
-                xml += '    <in-slices>\n';
-                for (const slice of slices) {
-                    xml += `      <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>\n`;
-                }
-                xml += '    </in-slices>\n';
-            }
-            xml += '  </processor>';
-            xmlResults.push(xml);
-        }
-    }
-    // Search slices
-    for (const slice of model.slices.values()) {
-        if (slice.name.toLowerCase().includes(termLower)) {
-            // JSON result
-            jsonResults.push({ type: 'slice', name: slice.name });
-            // XML result
-            xmlResults.push(`  <slice name="${escapeXml(slice.name)}" status="${slice.status}"/>`);
-        }
-    }
-    // Search aggregates
-    for (const agg of model.aggregates.values()) {
-        if (agg.name.toLowerCase().includes(termLower)) {
-            const events = agg.eventIds
-                .map(id => model.events.get(id))
-                .filter((e) => e !== undefined);
-            // JSON result
-            const jsonResult = { type: 'aggregate', name: agg.name, events: events.length };
-            if (events.length > 0) {
-                jsonResult.contains = events.map(e => e.name);
-            }
-            jsonResults.push(jsonResult);
-            // XML result
-            let xml = `  <aggregate name="${escapeXml(agg.name)}" events="${events.length}">\n`;
-            if (events.length > 0) {
-                xml += '    <contains>\n';
-                for (const evt of events) {
-                    xml += `      <event name="${escapeXml(evt.name)}"/>\n`;
-                }
-                xml += '    </contains>\n';
-            }
-            xml += '  </aggregate>';
-            xmlResults.push(xml);
-        }
-    }
-    // Search actors
-    for (const actor of model.actors.values()) {
-        if (actor.name.toLowerCase().includes(termLower)) {
-            const screens = actor.screenIds
-                .map(id => model.screens.get(id))
-                .filter((s) => s !== undefined);
-            // JSON result
-            const jsonResult = { type: 'actor', name: actor.name, screens: screens.length };
-            if (screens.length > 0) {
-                jsonResult.contains = screens.map(s => s.name);
-            }
-            jsonResults.push(jsonResult);
-            // XML result
-            let xml = `  <actor name="${escapeXml(actor.name)}" screens="${screens.length}">\n`;
-            if (screens.length > 0) {
-                xml += '    <contains>\n';
-                for (const scr of screens) {
-                    xml += `      <screen name="${escapeXml(scr.name)}"/>\n`;
-                }
-                xml += '    </contains>\n';
-            }
-            xml += '  </actor>';
-            xmlResults.push(xml);
-        }
-    }
-    // Search scenarios
-    for (const scenario of model.scenarios.values()) {
-        if (scenario.name.toLowerCase().includes(termLower)) {
-            const slice = model.slices.get(scenario.sliceId);
-            // JSON result
-            const jsonResult = { type: 'scenario', name: scenario.name };
-            if (slice) {
-                jsonResult.inSlice = { name: slice.name, status: slice.status };
-            }
-            jsonResults.push(jsonResult);
-            // XML result
-            let xml = `  <scenario name="${escapeXml(scenario.name)}">\n`;
-            if (slice) {
-                xml += `    <in-slice name="${escapeXml(slice.name)}" status="${slice.status}"/>\n`;
-            }
-            xml += '  </scenario>';
-            xmlResults.push(xml);
-        }
-    }
-    if (format === 'json') {
-        outputJson({ query: term, count: jsonResults.length, results: jsonResults });
-        return;
-    }
-    if (xmlResults.length === 0) {
-        console.log(`<search-results query="${escapeXml(term)}" count="0"/>`);
-    }
-    else {
-        console.log(`<search-results query="${escapeXml(term)}" count="${xmlResults.length}">`);
-        for (const result of xmlResults) {
-            console.log(result);
-        }
-        console.log('</search-results>');
-    }
-}

package/dist/slices/show-actor/index.d.ts

@@ -1,4 +0,0 @@
-import type { EventModel } from '../../types.js';
-import { type OutputFormat } from '../../lib/format.js';
-export declare function showActor(model: EventModel, actorName: string, format: OutputFormat): void;
-export declare function listActors(model: EventModel, format: OutputFormat): void;