@nodish/base 0.1.0

package/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

package/dist/index.css

@@ -0,0 +1 @@
+.bool[data-v-71ee835c]{cursor:pointer;-webkit-user-select:none;user-select:none;flex:1;align-items:center;gap:6px;min-width:0;display:flex}.bool input[data-v-71ee835c]{accent-color:#86efac;flex:none;margin:0}.label[data-v-71ee835c]{white-space:nowrap;text-overflow:ellipsis;overflow:hidden}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { NodePack } from '@nodish/core';
+export declare const pack: NodePack;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAa7C,eAAO,MAAM,IAAI,EAAE,QAmBlB,CAAC"}

package/dist/index.js

@@ -0,0 +1,492 @@
+import { defineType as e } from "@nodish/core";
+import { createElementBlock as t, createElementVNode as n, defineComponent as r, openBlock as i, toDisplayString as a, withModifiers as o } from "vue";
+import './index.css';//#region src/types/number.ts
+var s = e({
+	id: "number",
+	label: "Number",
+	color: "#7dd3fc",
+	validate: (e) => typeof e == "number" && !Number.isNaN(e),
+	defaultValue: 0,
+	widget: { kind: "number" }
+}), c = "boolean", l = e({
+	id: "boolean",
+	label: "Boolean",
+	color: "#86efac",
+	validate: (e) => typeof e == "boolean",
+	defaultValue: !1,
+	widget: {
+		kind: "custom",
+		componentId: c
+	},
+	coerce: (e) => e === !0,
+	format: (e) => e === !0 ? "true" : "false"
+}), u = ["title"], ee = ["checked"], te = { class: "label" }, d = /*#__PURE__*/ ((e, t) => {
+	let n = e.__vccOpts || e;
+	for (let [e, r] of t) n[e] = r;
+	return n;
+})(/* @__PURE__ */ r({
+	__name: "boolean",
+	props: {
+		port: {},
+		typeDef: {},
+		placeholder: {}
+	},
+	emits: ["update:value", "commit"],
+	setup(e, { emit: r }) {
+		let s = r;
+		function c(e) {
+			let t = e.target.checked;
+			s("update:value", t), s("commit");
+		}
+		return (r, s) => (i(), t("label", {
+			class: "bool",
+			title: e.port.name,
+			onPointerdown: s[0] ||= o(() => {}, ["stop"])
+		}, [n("input", {
+			type: "checkbox",
+			checked: e.port.value === !0,
+			onChange: c
+		}, null, 40, ee), n("span", te, a(e.port.name), 1)], 40, u));
+	}
+}), [["__scopeId", "data-v-71ee835c"]]), f = {
+	typeId: "add",
+	displayName: "Add",
+	inputs: {
+		a: { type: "number" },
+		b: { type: "number" }
+	},
+	outputs: { result: { type: "number" } },
+	group: ["math", "basic"],
+	execute: (e) => ({ result: e.a + e.b })
+}, p = {
+	typeId: "subtract",
+	displayName: "Subtract",
+	inputs: {
+		a: { type: "number" },
+		b: { type: "number" }
+	},
+	outputs: { result: { type: "number" } },
+	group: ["math", "basic"],
+	execute: (e) => ({ result: e.a - e.b })
+}, m = {
+	typeId: "multiply",
+	displayName: "Multiply",
+	inputs: {
+		a: { type: "number" },
+		b: { type: "number" }
+	},
+	outputs: { result: { type: "number" } },
+	group: ["math", "basic"],
+	execute: (e) => ({ result: e.a * e.b })
+}, h = {
+	typeId: "divide",
+	displayName: "Divide",
+	inputs: {
+		a: { type: "number" },
+		b: { type: "number" }
+	},
+	outputs: { result: { type: "number" } },
+	group: ["math", "basic"],
+	execute: (e) => ({ result: e.a / e.b })
+}, g = {
+	typeId: "power",
+	displayName: "Power",
+	inputs: {
+		base: { type: "number" },
+		exponent: { type: "number" }
+	},
+	outputs: { result: { type: "number" } },
+	group: ["math", "basic"],
+	execute: (e) => ({ result: e.base ** +e.exponent })
+}, _ = {
+	typeId: "ceil",
+	displayName: "Ceil",
+	inputs: { value: { type: "number" } },
+	outputs: { result: { type: "number" } },
+	group: [
+		"math",
+		"basic",
+		"rounding"
+	],
+	execute: (e) => ({ result: Math.ceil(e.value) })
+}, v = {
+	typeId: "floor",
+	displayName: "Floor",
+	inputs: { value: { type: "number" } },
+	outputs: { result: { type: "number" } },
+	group: [
+		"math",
+		"basic",
+		"rounding"
+	],
+	execute: (e) => ({ result: Math.floor(e.value) })
+}, y = {
+	typeId: "round",
+	displayName: "Round",
+	inputs: { value: { type: "number" } },
+	outputs: { result: { type: "number" } },
+	group: [
+		"math",
+		"basic",
+		"rounding"
+	],
+	execute: (e) => ({ result: Math.round(e.value) })
+}, b = {
+	typeId: "absolute",
+	displayName: "Absolute value",
+	inputs: { value: { type: "number" } },
+	outputs: { result: { type: "number" } },
+	group: ["math", "basic"],
+	execute: (e) => ({ result: Math.abs(e.value) })
+}, x = {
+	typeId: "mapping",
+	displayName: "Mapping",
+	inputs: {
+		value: { type: "number" },
+		inputMin: { type: "number" },
+		inputMax: { type: "number" },
+		outputMin: { type: "number" },
+		outputMax: { type: "number" },
+		clamp: { type: "boolean" }
+	},
+	outputs: { result: { type: "number" } },
+	group: ["math", "basic"],
+	execute: (e) => {
+		let t = e.value, n = e.inputMin, r = e.inputMax, i = e.outputMin, a = e.outputMax;
+		return e.clamp && (t = Math.max(n, Math.min(t, r))), { result: ((t - n) * (a - i) + i) / (r - n) };
+	}
+}, ne = {
+	[f.typeId]: f,
+	[p.typeId]: p,
+	[m.typeId]: m,
+	[h.typeId]: h,
+	[g.typeId]: g,
+	[_.typeId]: _,
+	[v.typeId]: v,
+	[y.typeId]: y,
+	[b.typeId]: b,
+	[x.typeId]: x
+}, S = {
+	typeId: "sine",
+	displayName: "Sine",
+	inputs: { value: { type: "number" } },
+	outputs: { result: { type: "number" } },
+	group: ["math", "trigonometry"],
+	execute: (e) => ({ result: Math.sin(e.value) })
+}, C = {
+	typeId: "cosine",
+	displayName: "Cosine",
+	inputs: { value: { type: "number" } },
+	outputs: { result: { type: "number" } },
+	group: ["math", "trigonometry"],
+	execute: (e) => ({ result: Math.cos(e.value) })
+}, w = {
+	typeId: "tangent",
+	displayName: "Tangent",
+	inputs: { value: { type: "number" } },
+	outputs: { result: { type: "number" } },
+	group: ["math", "trigonometry"],
+	execute: (e) => ({ result: Math.tan(e.value) })
+}, T = {
+	typeId: "cotangent",
+	displayName: "Cotangent",
+	inputs: { value: { type: "number" } },
+	outputs: { result: { type: "number" } },
+	group: ["math", "trigonometry"],
+	execute: (e) => ({ result: 1 / Math.tan(e.value) })
+}, E = {
+	typeId: "secant",
+	displayName: "Secant",
+	inputs: { value: { type: "number" } },
+	outputs: { result: { type: "number" } },
+	group: ["math", "trigonometry"],
+	execute: (e) => ({ result: 1 / Math.cos(e.value) })
+}, D = {
+	typeId: "cosecant",
+	displayName: "Cosecant",
+	inputs: { value: { type: "number" } },
+	outputs: { result: { type: "number" } },
+	group: ["math", "trigonometry"],
+	execute: (e) => ({ result: 1 / Math.sin(e.value) })
+}, O = {
+	[S.typeId]: S,
+	[C.typeId]: C,
+	[w.typeId]: w,
+	[T.typeId]: T,
+	[E.typeId]: E,
+	[D.typeId]: D
+}, k = e({
+	id: "string",
+	label: "String",
+	color: "#f472b6",
+	validate: (e) => typeof e == "string",
+	defaultValue: "",
+	widget: {
+		kind: "text",
+		rows: 3
+	}
+}), A = {
+	typeId: "equals",
+	displayName: "Equals",
+	inputs: {
+		a: { type: "number" },
+		b: { type: "number" }
+	},
+	outputs: { result: { type: "boolean" } },
+	execute: (e) => ({ result: e.a === e.b })
+}, j = {
+	typeId: "greaterThan",
+	displayName: "Greater Than",
+	inputs: {
+		a: { type: "number" },
+		b: { type: "number" },
+		orEqual: { type: "boolean" }
+	},
+	outputs: { result: { type: "boolean" } },
+	execute: (e) => {
+		let t = e.a, n = e.b, r = e.orEqual;
+		return { result: t > n || r && t === n };
+	}
+}, M = {
+	typeId: "lessThan",
+	displayName: "Less Than",
+	inputs: {
+		a: { type: "number" },
+		b: { type: "number" },
+		orEqual: { type: "boolean" }
+	},
+	outputs: { result: { type: "boolean" } },
+	execute: (e) => {
+		let t = e.a, n = e.b, r = e.orEqual;
+		return { result: t < n || r && t === n };
+	}
+}, re = {
+	[A.typeId]: A,
+	[j.typeId]: j,
+	[M.typeId]: M
+}, N = {
+	typeId: "concatenate",
+	displayName: "Concatenate",
+	inputs: {
+		a: { type: "string" },
+		b: { type: "string" }
+	},
+	outputs: { result: { type: "string" } },
+	group: ["text", "basic"],
+	execute: (e) => ({ result: e.a + e.b })
+}, P = {
+	typeId: "length",
+	displayName: "Length",
+	inputs: { value: { type: "string" } },
+	outputs: { result: { type: "number" } },
+	group: ["text", "basic"],
+	execute: (e) => ({ result: e.value.length })
+}, F = {
+	typeId: "trim",
+	displayName: "Trim",
+	inputs: { value: { type: "string" } },
+	outputs: { result: { type: "string" } },
+	group: ["text", "basic"],
+	execute: (e) => ({ result: e.value.trim() })
+}, I = {
+	typeId: "toUpperCase",
+	displayName: "To Upper Case",
+	inputs: { value: { type: "string" } },
+	outputs: { result: { type: "string" } },
+	group: ["text", "basic"],
+	execute: (e) => ({ result: e.value.toUpperCase() })
+}, L = {
+	typeId: "simpleReplace",
+	displayName: "Simple Replace",
+	inputs: {
+		value: { type: "string" },
+		old: { type: "string" },
+		new: { type: "string" }
+	},
+	outputs: { result: { type: "string" } },
+	group: ["text", "basic"],
+	execute: (e) => ({ result: e.value.replace(e.old, e.new) })
+}, R = {
+	[N.typeId]: N,
+	[P.typeId]: P,
+	[F.typeId]: F,
+	[I.typeId]: I,
+	[L.typeId]: L
+}, z = {
+	typeId: "equals",
+	displayName: "Equals",
+	inputs: {
+		a: { type: "string" },
+		b: { type: "string" }
+	},
+	outputs: { result: { type: "boolean" } },
+	execute: (e) => ({ result: e.a === e.b })
+}, B = {
+	typeId: "greaterThan",
+	displayName: "Greater Than",
+	inputs: {
+		a: { type: "string" },
+		b: { type: "string" },
+		orEqual: { type: "boolean" }
+	},
+	outputs: { result: { type: "boolean" } },
+	execute: (e) => {
+		let t = e.a, n = e.b, r = e.orEqual;
+		return { result: t > n || r && t === n };
+	}
+}, V = {
+	typeId: "lessThan",
+	displayName: "Less Than",
+	inputs: {
+		a: { type: "string" },
+		b: { type: "string" },
+		orEqual: { type: "boolean" }
+	},
+	outputs: { result: { type: "boolean" } },
+	execute: (e) => {
+		let t = e.a, n = e.b, r = e.orEqual;
+		return { result: t < n || r && t === n };
+	}
+}, H = {
+	typeId: "contains",
+	displayName: "Contains",
+	inputs: {
+		a: { type: "string" },
+		b: { type: "string" }
+	},
+	outputs: { result: { type: "boolean" } },
+	execute: (e) => ({ result: e.a.includes(e.b) })
+}, U = {
+	typeId: "toLowerCase",
+	displayName: "To Lower Case",
+	inputs: { value: { type: "string" } },
+	outputs: { result: { type: "string" } },
+	group: ["text", "basic"],
+	execute: (e) => ({ result: e.value.toLowerCase() })
+}, W = {
+	typeId: "startsWith",
+	displayName: "Starts With",
+	inputs: {
+		value: { type: "string" },
+		prefix: { type: "string" }
+	},
+	outputs: { result: { type: "boolean" } },
+	group: ["text", "basic"],
+	execute: (e) => ({ result: e.value.startsWith(e.prefix) })
+}, G = {
+	[z.typeId]: z,
+	[B.typeId]: B,
+	[V.typeId]: V,
+	[H.typeId]: H,
+	[U.typeId]: U,
+	[W.typeId]: W
+}, K = {
+	typeId: "not",
+	displayName: "Not",
+	inputs: { value: { type: "boolean" } },
+	outputs: { result: { type: "boolean" } },
+	group: ["boolean", "basic"],
+	execute: (e) => ({ result: !e.value })
+}, q = {
+	typeId: "or",
+	displayName: "Or",
+	inputs: {
+		a: { type: "boolean" },
+		b: { type: "boolean" }
+	},
+	outputs: { result: { type: "boolean" } },
+	group: ["boolean", "basic"],
+	execute: (e) => ({ result: e.a || e.b })
+}, J = {
+	typeId: "and",
+	displayName: "And",
+	inputs: {
+		a: { type: "boolean" },
+		b: { type: "boolean" }
+	},
+	outputs: { result: { type: "boolean" } },
+	group: ["boolean", "basic"],
+	execute: (e) => ({ result: e.a && e.b })
+}, Y = {
+	typeId: "xor",
+	displayName: "Xor",
+	inputs: {
+		a: { type: "boolean" },
+		b: { type: "boolean" }
+	},
+	outputs: { result: { type: "boolean" } },
+	group: ["boolean", "basic"],
+	execute: (e) => ({ result: e.a !== e.b })
+}, X = {
+	typeId: "nand",
+	displayName: "Nand",
+	inputs: {
+		a: { type: "boolean" },
+		b: { type: "boolean" }
+	},
+	outputs: { result: { type: "boolean" } },
+	group: ["boolean", "basic"],
+	execute: (e) => ({ result: !(e.a && e.b) })
+}, Z = {
+	typeId: "nor",
+	displayName: "Nor",
+	inputs: {
+		a: { type: "boolean" },
+		b: { type: "boolean" }
+	},
+	outputs: { result: { type: "boolean" } },
+	group: ["boolean", "basic"],
+	execute: (e) => ({ result: !(e.a || e.b) })
+}, ie = {
+	[K.typeId]: K,
+	[q.typeId]: q,
+	[J.typeId]: J,
+	[Y.typeId]: Y,
+	[X.typeId]: X,
+	[Z.typeId]: Z
+}, Q = {
+	typeId: "regexMatch",
+	displayName: "Regex Match",
+	inputs: {
+		value: { type: "string" },
+		regex: { type: "string" }
+	},
+	outputs: { result: { type: "boolean" } },
+	group: ["text", "regex"],
+	execute: (e) => ({ result: e.value.match(e.regex) })
+}, $ = {
+	typeId: "regexReplace",
+	displayName: "Regex Replace",
+	inputs: {
+		value: { type: "string" },
+		regex: { type: "string" },
+		replacement: { type: "string" }
+	},
+	outputs: { result: { type: "string" } },
+	group: ["text", "regex"],
+	execute: (e) => ({ result: e.value.replace(e.regex, e.replacement) })
+}, ae = {
+	[Q.typeId]: Q,
+	[$.typeId]: $
+}, oe = {
+	id: "@nodish/base",
+	nodeTypes: {
+		...ne,
+		...O,
+		...re,
+		...R,
+		...G,
+		...ie,
+		...ae
+	},
+	types: {
+		number: s,
+		boolean: l,
+		string: k
+	},
+	setup({ registerComponentWidget: e }) {
+		e(c, d);
+	}
+};
+//#endregion
+export { oe as pack };

package/dist/nodes/boolean/basic.d.ts

@@ -0,0 +1,9 @@
+import { NodeSpecRegistry, NodeSpec } from '@nodish/core';
+export declare const not: NodeSpec;
+export declare const or: NodeSpec;
+export declare const and: NodeSpec;
+export declare const xor: NodeSpec;
+export declare const nand: NodeSpec;
+export declare const nor: NodeSpec;
+export declare const booleanBasicNodes: NodeSpecRegistry;
+//# sourceMappingURL=basic.d.ts.map

package/dist/nodes/boolean/basic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic.d.ts","sourceRoot":"","sources":["../../../src/nodes/boolean/basic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE/D,eAAO,MAAM,GAAG,EAAE,QAWjB,CAAC;AAEF,eAAO,MAAM,EAAE,EAAE,QAYhB,CAAC;AAEF,eAAO,MAAM,GAAG,EAAE,QAYjB,CAAC;AAEF,eAAO,MAAM,GAAG,EAAE,QAYjB,CAAC;AAEF,eAAO,MAAM,IAAI,EAAE,QAYlB,CAAC;AAEF,eAAO,MAAM,GAAG,EAAE,QAYjB,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,gBAO/B,CAAC"}

package/dist/nodes/math/basic.d.ts

@@ -0,0 +1,14 @@
+import { NodeSpecRegistry, NodeSpec } from '@nodish/core';
+export declare const add: NodeSpec;
+export declare const subtract: NodeSpec;
+export declare const multiply: NodeSpec;
+export declare const divide: NodeSpec;
+export declare const power: NodeSpec;
+export declare const ceil: NodeSpec;
+export declare const floor: NodeSpec;
+export declare const round: NodeSpec;
+export declare const absolute: NodeSpec;
+export declare const modulo: NodeSpec;
+export declare const mapping: NodeSpec;
+export declare const basicMathNodes: NodeSpecRegistry;
+//# sourceMappingURL=basic.d.ts.map

package/dist/nodes/math/basic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic.d.ts","sourceRoot":"","sources":["../../../src/nodes/math/basic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAC/D,eAAO,MAAM,GAAG,EAAE,QAYjB,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,QAYtB,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,QAYtB,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,QAYpB,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,QAcnB,CAAC;AAEF,eAAO,MAAM,IAAI,EAAE,QAWlB,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,QAWnB,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,QAWnB,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,QAWtB,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,QAYpB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,QA4BrB,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,gBAW5B,CAAC"}

package/dist/nodes/math/compare.d.ts

@@ -0,0 +1,6 @@
+import { NodeSpecRegistry, NodeSpec } from '@nodish/core';
+export declare const equals: NodeSpec;
+export declare const greaterThan: NodeSpec;
+export declare const lessThan: NodeSpec;
+export declare const mathCompareNodes: NodeSpecRegistry;
+//# sourceMappingURL=compare.d.ts.map

package/dist/nodes/math/compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../../src/nodes/math/compare.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE/D,eAAO,MAAM,MAAM,EAAE,QAWpB,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,QAiBzB,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,QAiBtB,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,gBAI9B,CAAC"}

package/dist/nodes/math/trig.d.ts

@@ -0,0 +1,9 @@
+import { NodeSpecRegistry, NodeSpec } from '@nodish/core';
+export declare const sine: NodeSpec;
+export declare const cosine: NodeSpec;
+export declare const tangent: NodeSpec;
+export declare const cotangent: NodeSpec;
+export declare const secant: NodeSpec;
+export declare const cosecant: NodeSpec;
+export declare const trigMathNodes: NodeSpecRegistry;
+//# sourceMappingURL=trig.d.ts.map

package/dist/nodes/math/trig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trig.d.ts","sourceRoot":"","sources":["../../../src/nodes/math/trig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE/D,eAAO,MAAM,IAAI,EAAE,QAWlB,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,QAWpB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,QAWrB,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,QAWvB,CAAC;AACF,eAAO,MAAM,MAAM,EAAE,QAWpB,CAAC;AACF,eAAO,MAAM,QAAQ,EAAE,QAWtB,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,gBAO3B,CAAC"}

package/dist/nodes/text/basic.d.ts

@@ -0,0 +1,8 @@
+import { NodeSpecRegistry, NodeSpec } from '@nodish/core';
+export declare const concatenate: NodeSpec;
+export declare const length: NodeSpec;
+export declare const trim: NodeSpec;
+export declare const toUpperCase: NodeSpec;
+export declare const simpleReplace: NodeSpec;
+export declare const textBasicNodes: NodeSpecRegistry;
+//# sourceMappingURL=basic.d.ts.map

package/dist/nodes/text/basic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic.d.ts","sourceRoot":"","sources":["../../../src/nodes/text/basic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE/D,eAAO,MAAM,WAAW,EAAE,QAYzB,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,QAWpB,CAAC;AAEF,eAAO,MAAM,IAAI,EAAE,QAWlB,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,QAWzB,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,QAkB3B,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,gBAM5B,CAAC"}

package/dist/nodes/text/compare.d.ts

@@ -0,0 +1,9 @@
+import { NodeSpecRegistry, NodeSpec } from '@nodish/core';
+export declare const equals: NodeSpec;
+export declare const greaterThan: NodeSpec;
+export declare const lessThan: NodeSpec;
+export declare const contains: NodeSpec;
+export declare const toLowerCase: NodeSpec;
+export declare const startsWith: NodeSpec;
+export declare const textCompareNodes: NodeSpecRegistry;
+//# sourceMappingURL=compare.d.ts.map

package/dist/nodes/text/compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../../src/nodes/text/compare.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE/D,eAAO,MAAM,MAAM,EAAE,QAWpB,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,QAiBzB,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,QAiBtB,CAAC;AAEF,eAAO,MAAM,QAAQ,EAAE,QAWtB,CAAC;AAEF,eAAO,MAAM,WAAW,EAAE,QAWzB,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,QAcxB,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,gBAO9B,CAAC"}

package/dist/nodes/text/regex.d.ts

@@ -0,0 +1,5 @@
+import { NodeSpecRegistry, NodeSpec } from '@nodish/core';
+export declare const regexMatch: NodeSpec;
+export declare const regexReplace: NodeSpec;
+export declare const regexNodes: NodeSpecRegistry;
+//# sourceMappingURL=regex.d.ts.map

package/dist/nodes/text/regex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex.d.ts","sourceRoot":"","sources":["../../../src/nodes/text/regex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAE/D,eAAO,MAAM,UAAU,EAAE,QAYxB,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,QAkB1B,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,gBAGxB,CAAC"}

package/dist/types/boolean/boolean.d.ts

@@ -0,0 +1,3 @@
+export declare const BOOLEAN_WIDGET_ID = "boolean";
+export declare const boolean: import('@nodish/core').PortTypeDefinition;
+//# sourceMappingURL=boolean.d.ts.map

package/dist/types/boolean/boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../../src/types/boolean/boolean.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,iBAAiB,YAAY,CAAC;AAC3C,eAAO,MAAM,OAAO,2CASlB,CAAC"}

package/dist/types/boolean/boolean.vue.d.ts

@@ -0,0 +1,15 @@
+import { Port, PortTypeDefinition } from '@nodish/core';
+type __VLS_Props = {
+    port: Port;
+    typeDef?: PortTypeDefinition;
+    placeholder: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:value": (value: unknown) => any;
+    commit: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:value"?: ((value: unknown) => any) | undefined;
+    onCommit?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLLabelElement>;
+export default _default;
+//# sourceMappingURL=boolean.vue.d.ts.map

package/dist/types/boolean/boolean.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.vue.d.ts","sourceRoot":"","sources":["../../../src/types/boolean/boolean.vue"],"names":[],"mappings":"AAmDA,OAAO,KAAK,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAE7D,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,IAAI,CAAC;IACX,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;;;;;;;;AAsEF,wBAQG"}

package/dist/types/number.d.ts

@@ -0,0 +1,3 @@
+export declare const number: import('@nodish/core').PortTypeDefinition;
+export type NumberType = number;
+//# sourceMappingURL=number.d.ts.map

package/dist/types/number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number.d.ts","sourceRoot":"","sources":["../../src/types/number.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,2CAOjB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC"}

package/dist/types/string.d.ts

@@ -0,0 +1,3 @@
+export declare const string: import('@nodish/core').PortTypeDefinition;
+export type StringType = string;
+//# sourceMappingURL=string.d.ts.map

package/dist/types/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/types/string.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,2CAOjB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC"}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@nodish/base",
+  "version": "0.1.0",
+  "description": "base nodepack for nodish",
+  "license": "AGPL-3.0-or-later",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "style": "./dist/index.css"
+    }
+  },
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "scripts": {
+    "dev": "vite --config vite.config.dev.ts",
+    "build": "vite build --config vite.config.ts",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "typecheck:dev": "tsc --noEmit -p tsconfig.dev.json"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.0"
+  },
+  "devDependencies": {
+    "@nodish/core": "^0.2.1",
+    "@types/node": "^26.0.1",
+    "@vitejs/plugin-vue": "^6.0.7",
+    "typescript": "^6.0.3",
+    "vite": "^8.1.2",
+    "vite-plugin-dts": "^4.5.4",
+    "vite-plugin-lib-inject-css": "^2.2.2",
+    "vue": "^3.5.39"
+  }
+}