@selenite/graph-editor/dist/graph-editor/nodes/data/number.js

A graph editor for visual programming, based on rete and svelte.

/**
 * Nodes for creating and manipulating numbers.
 * @module
 */
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
import { description, Node, registerConverter, registerNode, tags } from '../Node.svelte';
import { ConverterNode, InputControlNode } from './common-data-nodes.svelte';
/**
 * A node that outputs a number.
 */
let NumberNode = class NumberNode extends InputControlNode {
    constructor(params) {
        super({ label: 'Number', ...params, controlType: 'number', props: { class: 'w-3' } });
    }
};
NumberNode = __decorate([
    registerNode('number.NumberNode'),
    description('Produces a number.'),
    tags('float', 'real', 'x', 'y', 'z', 't'),
    __metadata("design:paramtypes", [Object])
], NumberNode);
export { NumberNode };
let ToStringNode = class ToStringNode extends ConverterNode {
    constructor(params = {}) {
        super({
            label: 'To string',
            ...params,
            source: 'number',
            target: 'string',
            convert: (e) => String(e)
        });
    }
};
ToStringNode = __decorate([
    registerNode('number.ToString'),
    description('Converts a number to a string.'),
    registerConverter('number', 'string'),
    tags('string', 'text', 'convert'),
    __metadata("design:paramtypes", [Object])
], ToStringNode);
export { ToStringNode };
let FloorNode = class FloorNode extends ConverterNode {
    constructor(params = {}) {
        super({
            label: 'Floor',
            ...params,
            source: 'number',
            target: 'integer',
            convert: (e) => Math.floor(e)
        });
    }
};
FloorNode = __decorate([
    registerNode('number.Floor'),
    description('Gets the largest integer less than or equal to a number.'),
    registerConverter('number', 'integer'),
    tags('int', 'convert', 'partie entière'),
    __metadata("design:paramtypes", [Object])
], FloorNode);
export { FloorNode };
let CeilNode = class CeilNode extends ConverterNode {
    constructor(params = {}) {
        super({
            label: 'Ceil',
            ...params,
            source: 'number',
            target: 'integer',
            convert: (e) => Math.ceil(e)
        });
    }
};
CeilNode = __decorate([
    registerNode('number.Ceil'),
    description('Gets the smallest integer greater than or equal to a number.'),
    registerConverter('number', 'integer'),
    tags('int', 'convert'),
    __metadata("design:paramtypes", [Object])
], CeilNode);
export { CeilNode };
let RoundNode = class RoundNode extends ConverterNode {
    constructor(params = {}) {
        super({
            label: 'Round',
            ...params,
            source: 'number',
            target: 'integer',
            convert: (e) => Math.round(e)
        });
    }
};
RoundNode = __decorate([
    registerNode('number.Round'),
    description('Gets the closest integer to a number.'),
    registerConverter('number', 'integer'),
    tags('int', 'convert', 'arrondir'),
    __metadata("design:paramtypes", [Object])
], RoundNode);
export { RoundNode };
let ParseNode = class ParseNode extends ConverterNode {
    constructor(params = {}) {
        super({
            label: 'Parse Number',
            ...params,
            source: 'string',
            target: 'number',
            convert: (e) => parseFloat(e)
        });
    }
};
ParseNode = __decorate([
    registerNode('number.Parse'),
    description('Parses a string to a number.'),
    registerConverter('string', 'number'),
    tags('float', 'convert'),
    __metadata("design:paramtypes", [Object])
], ParseNode);
export { ParseNode };
let ToBoolNode = class ToBoolNode extends ConverterNode {
    constructor(params = {}) {
        super({
            label: 'To boolean',
            ...params,
            source: 'number',
            target: 'boolean',
            convert: (e) => Boolean(e)
        });
    }
};
ToBoolNode = __decorate([
    registerNode('number.ToBool'),
    description('Converts a number to a boolean.'),
    registerConverter('number', 'boolean'),
    tags('bool', 'convert'),
    __metadata("design:paramtypes", [Object])
], ToBoolNode);
export { ToBoolNode };
let MultiplyNode = class MultiplyNode extends Node {
    constructor(params = {}) {
        super({ label: 'Multiply', ...params });
        this.addInData('a', {
            type: 'number'
        });
        this.addInData('b', {
            type: 'number'
        });
        this.addOutData('value', {
            type: 'number'
        });
    }
    data(inputs) {
        return { value: this.getData('a', inputs) * this.getData('b', inputs) };
    }
};
MultiplyNode = __decorate([
    registerNode('number.Multiply'),
    description('Multiplies two numbers.'),
    tags('multiply', 'x', '*'),
    __metadata("design:paramtypes", [Object])
], MultiplyNode);
export { MultiplyNode };