@nudojs/core 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @nudojs/core
 
+## 0.2.0
+
+### Minor Changes
+
+- 6c38283: docs and ci
+- 9f7f819: fix pkg info
+- c175f71: version
+
 ## 0.1.0
 
 ### Minor Changes

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nudo Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

package/dist/index.d.ts

@@ -12,12 +12,24 @@ type Environment = {
 declare function createEnvironment(parent?: Environment, bindings?: Map<string, TypeValue>): Environment;
 
 type LiteralValue = string | number | boolean | null | undefined;
+type Refinement = {
+    name: string;
+    meta: Record<string, unknown>;
+    check?: (value: unknown) => boolean;
+    ops?: Record<string, (self: TypeValue, other: TypeValue) => TypeValue | undefined>;
+    methods?: Record<string, (self: TypeValue, args: TypeValue[]) => TypeValue | undefined>;
+    properties?: Record<string, (self: TypeValue) => TypeValue | undefined>;
+};
 type TypeValue = {
     kind: "literal";
     value: LiteralValue;
 } | {
     kind: "primitive";
     type: "number" | "string" | "boolean" | "bigint" | "symbol";
+} | {
+    kind: "refined";
+    base: TypeValue;
+    refinement: Refinement;
 } | {
     kind: "object";
     properties: Record<string, TypeValue>;
@@ -67,6 +79,7 @@ declare const T: {
     readonly instanceOf: (className: string, properties?: Record<string, TypeValue>) => TypeValue;
     readonly union: typeof createUnion;
     readonly fn: (params: string[], body: Node, closure: Environment) => TypeValue;
+    readonly refine: (base: TypeValue, refinement: Refinement) => TypeValue;
 };
 declare function typeValueEquals(a: TypeValue, b: TypeValue): boolean;
 declare function simplifyUnion(members: TypeValue[]): TypeValue;
@@ -82,6 +95,7 @@ declare function typeValueToString(tv: TypeValue): string;
 declare function narrowType(tv: TypeValue, predicate: (member: TypeValue) => boolean): TypeValue;
 declare function subtractType(tv: TypeValue, predicate: (member: TypeValue) => boolean): TypeValue;
 declare function getPrimitiveTypeOf(tv: TypeValue): string | undefined;
+declare function getRefinedBase(tv: TypeValue): TypeValue;
 
 declare const Ops: {
     readonly add: (left: TypeValue, right: TypeValue) => TypeValue;
@@ -100,5 +114,24 @@ declare const Ops: {
     readonly neg: (operand: TypeValue) => TypeValue;
 };
 declare function applyBinaryOp(op: string, left: TypeValue, right: TypeValue): TypeValue;
+declare function dispatchBinaryOp(op: string, left: TypeValue, right: TypeValue): TypeValue;
+declare function dispatchMethod(receiver: TypeValue, name: string, args: TypeValue[]): TypeValue | undefined;
+declare function dispatchProperty(receiver: TypeValue, name: string): TypeValue | undefined;
+
+declare function getKnownPrefix(parts: TypeValue[]): string;
+declare function getKnownSuffix(parts: TypeValue[]): string;
+declare function createTemplate(parts: TypeValue[]): TypeValue;
+declare function isTemplate(tv: TypeValue): boolean;
+declare function getTemplateParts(tv: TypeValue): TypeValue[] | undefined;
+declare function concatTemplates(left: TypeValue, right: TypeValue): TypeValue;
+
+type RangeMeta = {
+    min?: number;
+    max?: number;
+    integer?: boolean;
+};
+declare function createRange(meta: RangeMeta): TypeValue;
+declare function isRange(tv: TypeValue): boolean;
+declare function getRangeMeta(tv: TypeValue): RangeMeta | undefined;
 
-export { type Environment, type LiteralValue, Ops, T, type TypeValue, applyBinaryOp, createEnvironment, deepCloneTypeValue, getPrimitiveTypeOf, isSubtypeOf, mergeObjectProperties, narrowType, simplifyUnion, subtractType, typeValueEquals, typeValueToString, widenLiteral };
+export { type Environment, type LiteralValue, Ops, type RangeMeta, type Refinement, T, type TypeValue, applyBinaryOp, concatTemplates, createEnvironment, createRange, createTemplate, deepCloneTypeValue, dispatchBinaryOp, dispatchMethod, dispatchProperty, getKnownPrefix, getKnownSuffix, getPrimitiveTypeOf, getRangeMeta, getRefinedBase, getTemplateParts, isRange, isSubtypeOf, isTemplate, mergeObjectProperties, narrowType, simplifyUnion, subtractType, typeValueEquals, typeValueToString, widenLiteral };

package/dist/index.js

@@ -32,6 +32,11 @@ var T = {
     params,
     body,
     closure
+  }),
+  refine: (base, refinement) => ({
+    kind: "refined",
+    base,
+    refinement
   })
 };
 function typeValueEquals(a, b) {
@@ -40,6 +45,9 @@ function typeValueEquals(a, b) {
   if (a.kind === "primitive" && b.kind === "primitive") return a.type === b.type;
   if (a.kind === "never" && b.kind === "never") return true;
   if (a.kind === "unknown" && b.kind === "unknown") return true;
+  if (a.kind === "refined" && b.kind === "refined") {
+    return a.refinement.name === b.refinement.name && typeValueEquals(a.base, b.base);
+  }
   if (a.kind === "promise" && b.kind === "promise") {
     return typeValueEquals(a.value, b.value);
   }
@@ -93,6 +101,16 @@ function isSubtypeOf(a, b) {
     if (b.type === "boolean" && typeof v === "boolean") return true;
     return false;
   }
+  if (a.kind === "literal" && b.kind === "refined") {
+    if (!isSubtypeOf(a, b.base)) return false;
+    return b.refinement.check ? b.refinement.check(a.value) : false;
+  }
+  if (a.kind === "refined") {
+    if (b.kind === "refined" && a.refinement.name === b.refinement.name) {
+      return isSubtypeOf(a.base, b.base);
+    }
+    return isSubtypeOf(a.base, b);
+  }
   if (a.kind === "object" && b.kind === "object") {
     return Object.entries(b.properties).every(
       ([k, bv]) => k in a.properties && isSubtypeOf(a.properties[k], bv)
@@ -164,6 +182,9 @@ function deepCloneTypeValue(tv, idMap) {
     }
     return { kind: "instance", className: tv.className, properties: newProps };
   }
+  if (tv.kind === "refined") {
+    return { kind: "refined", base: deepCloneTypeValue(tv.base, map), refinement: tv.refinement };
+  }
   if (tv.kind === "union") {
     return simplifyUnion(tv.members.map((m) => deepCloneTypeValue(m, map)));
   }
@@ -194,6 +215,8 @@ function typeValueToString(tv) {
     }
     case "primitive":
       return tv.type;
+    case "refined":
+      return tv.refinement.name;
     case "object": {
       const entries = Object.entries(tv.properties);
       if (entries.length === 0) return "{}";
@@ -243,6 +266,7 @@ function getPrimitiveTypeOf(tv) {
     return typeof v;
   }
   if (tv.kind === "primitive") return tv.type;
+  if (tv.kind === "refined") return getPrimitiveTypeOf(tv.base);
   if (tv.kind === "object") return "object";
   if (tv.kind === "array" || tv.kind === "tuple") return "object";
   if (tv.kind === "function") return "function";
@@ -250,6 +274,237 @@ function getPrimitiveTypeOf(tv) {
   if (tv.kind === "instance") return "object";
   return void 0;
 }
+function getRefinedBase(tv) {
+  return tv.kind === "refined" ? getRefinedBase(tv.base) : tv;
+}
+
+// src/refinements/range.ts
+function formatRangeName(meta) {
+  const parts = [];
+  if (meta.integer) parts.push("integer");
+  else parts.push("number");
+  const constraints = [];
+  if (meta.min != null) constraints.push(`>= ${meta.min}`);
+  if (meta.max != null) constraints.push(`<= ${meta.max}`);
+  if (constraints.length > 0) parts.push(`(${constraints.join(", ")})`);
+  return parts.join(" ");
+}
+function createRangeRefinement(meta) {
+  return {
+    name: formatRangeName(meta),
+    meta: { ...meta },
+    check(value) {
+      if (typeof value !== "number") return false;
+      if (meta.integer && !Number.isInteger(value)) return false;
+      if (meta.min != null && value < meta.min) return false;
+      if (meta.max != null && value > meta.max) return false;
+      return true;
+    },
+    ops: {
+      ">="(self, other) {
+        const m = getRangeMeta(self);
+        if (!m || other.kind !== "literal" || typeof other.value !== "number") return void 0;
+        if (m.min != null && m.min >= other.value) return T.literal(true);
+        if (m.max != null && m.max < other.value) return T.literal(false);
+        return void 0;
+      },
+      ">"(self, other) {
+        const m = getRangeMeta(self);
+        if (!m || other.kind !== "literal" || typeof other.value !== "number") return void 0;
+        if (m.min != null && m.min > other.value) return T.literal(true);
+        if (m.max != null && m.max <= other.value) return T.literal(false);
+        return void 0;
+      },
+      "<="(self, other) {
+        const m = getRangeMeta(self);
+        if (!m || other.kind !== "literal" || typeof other.value !== "number") return void 0;
+        if (m.max != null && m.max <= other.value) return T.literal(true);
+        if (m.min != null && m.min > other.value) return T.literal(false);
+        return void 0;
+      },
+      "<"(self, other) {
+        const m = getRangeMeta(self);
+        if (!m || other.kind !== "literal" || typeof other.value !== "number") return void 0;
+        if (m.max != null && m.max < other.value) return T.literal(true);
+        if (m.min != null && m.min >= other.value) return T.literal(false);
+        return void 0;
+      }
+    }
+  };
+}
+function createRange(meta) {
+  if (meta.min != null && meta.max != null && meta.min === meta.max) {
+    return T.literal(meta.min);
+  }
+  return T.refine(T.number, createRangeRefinement(meta));
+}
+function isRange(tv) {
+  if (tv.kind !== "refined") return false;
+  const m = tv.refinement.meta;
+  return m.min !== void 0 || m.max !== void 0 || m.integer !== void 0;
+}
+function getRangeMeta(tv) {
+  if (tv.kind !== "refined") return void 0;
+  const m = tv.refinement.meta;
+  if (m.min !== void 0 || m.max !== void 0 || m.integer !== void 0) {
+    return m;
+  }
+  return void 0;
+}
+
+// src/refinements/template.ts
+function getKnownPrefix(parts) {
+  let prefix = "";
+  for (const p of parts) {
+    if (p.kind === "literal" && typeof p.value === "string") {
+      prefix += p.value;
+    } else {
+      break;
+    }
+  }
+  return prefix;
+}
+function getKnownSuffix(parts) {
+  let suffix = "";
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const p = parts[i];
+    if (p.kind === "literal" && typeof p.value === "string") {
+      suffix = p.value + suffix;
+    } else {
+      break;
+    }
+  }
+  return suffix;
+}
+function getFixedLength(parts) {
+  let len = 0;
+  for (const p of parts) {
+    if (p.kind === "literal" && typeof p.value === "string") {
+      len += p.value.length;
+    }
+  }
+  return len;
+}
+function getAllFixedText(parts) {
+  return parts.filter((p) => p.kind === "literal" && typeof p.value === "string").map((p) => p.value).join("");
+}
+function formatTemplateName(parts) {
+  const inner = parts.map((p) => p.kind === "literal" && typeof p.value === "string" ? p.value : `\${${typeValueToString(p)}}`).join("");
+  return `\`${inner}\``;
+}
+function normalizeParts(parts) {
+  const result = [];
+  for (const p of parts) {
+    const last = result[result.length - 1];
+    if (last?.kind === "literal" && typeof last.value === "string" && p.kind === "literal" && typeof p.value === "string") {
+      result[result.length - 1] = T.literal(last.value + p.value);
+    } else if (last?.kind === "primitive" && last.type === "string" && p.kind === "primitive" && p.type === "string") {
+    } else {
+      result.push(p);
+    }
+  }
+  return result;
+}
+function createTemplateRefinement(parts) {
+  return {
+    name: formatTemplateName(parts),
+    meta: { parts },
+    check(value) {
+      if (typeof value !== "string") return false;
+      return matchesTemplate(value, parts);
+    },
+    ops: {
+      "+"(self, other) {
+        return concatTemplates(self, other);
+      }
+    },
+    methods: {
+      startsWith(_self, args) {
+        const arg = args[0];
+        if (arg?.kind !== "literal" || typeof arg.value !== "string") return void 0;
+        const prefix = getKnownPrefix(_self.refinement.meta.parts);
+        const search = arg.value;
+        if (prefix.length >= search.length) {
+          return T.literal(prefix.startsWith(search));
+        }
+        if (search.startsWith(prefix)) return void 0;
+        return T.literal(false);
+      },
+      endsWith(_self, args) {
+        const arg = args[0];
+        if (arg?.kind !== "literal" || typeof arg.value !== "string") return void 0;
+        const suffix = getKnownSuffix(_self.refinement.meta.parts);
+        const search = arg.value;
+        if (suffix.length >= search.length) {
+          return T.literal(suffix.endsWith(search));
+        }
+        if (search.endsWith(suffix)) return void 0;
+        return T.literal(false);
+      },
+      includes(_self, args) {
+        const arg = args[0];
+        if (arg?.kind !== "literal" || typeof arg.value !== "string") return void 0;
+        const fixed = getAllFixedText(_self.refinement.meta.parts);
+        if (fixed.includes(arg.value)) return T.literal(true);
+        return void 0;
+      }
+    },
+    properties: {
+      length(_self) {
+        const parts2 = _self.refinement.meta.parts;
+        const hasAbstract = parts2.some((p) => p.kind !== "literal");
+        if (!hasAbstract) return void 0;
+        const minLen = getFixedLength(parts2);
+        return createRange({ min: minLen });
+      }
+    }
+  };
+}
+function matchesTemplate(value, parts) {
+  let pos = 0;
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i];
+    if (p.kind === "literal" && typeof p.value === "string") {
+      if (!value.startsWith(p.value, pos)) return false;
+      pos += p.value.length;
+    } else {
+      if (i === parts.length - 1) return true;
+      const next = parts[i + 1];
+      if (next?.kind === "literal" && typeof next.value === "string") {
+        const idx = value.indexOf(next.value, pos);
+        if (idx === -1) return false;
+        pos = idx;
+      } else {
+        return true;
+      }
+    }
+  }
+  return pos === value.length;
+}
+function createTemplate(parts) {
+  const normalized = normalizeParts(parts);
+  if (normalized.length === 1 && normalized[0].kind === "literal") {
+    return normalized[0];
+  }
+  if (normalized.length === 1 && normalized[0].kind === "primitive" && normalized[0].type === "string") {
+    return T.string;
+  }
+  return T.refine(T.string, createTemplateRefinement(normalized));
+}
+function isTemplate(tv) {
+  return tv.kind === "refined" && Array.isArray(tv.refinement.meta.parts);
+}
+function getTemplateParts(tv) {
+  if (tv.kind === "refined" && Array.isArray(tv.refinement.meta.parts)) {
+    return tv.refinement.meta.parts;
+  }
+  return void 0;
+}
+function concatTemplates(left, right) {
+  const leftParts = getTemplateParts(left) ?? [left];
+  const rightParts = getTemplateParts(right) ?? [right];
+  return createTemplate([...leftParts, ...rightParts]);
+}
 
 // src/ops.ts
 function bothLiteral(l, r) {
@@ -264,7 +519,13 @@ var Ops = {
     if (lit) {
       return T.literal(lit.lv + lit.rv);
     }
-    if (isSubtypeOf(left, T.string) || isSubtypeOf(right, T.string)) {
+    const leftIsString = isSubtypeOf(left, T.string) || isTemplate(left);
+    const rightIsString = isSubtypeOf(right, T.string) || isTemplate(right);
+    if (leftIsString || rightIsString) {
+      const hasStructure = left.kind === "literal" && typeof left.value === "string" || right.kind === "literal" && typeof right.value === "string" || isTemplate(left) || isTemplate(right);
+      if (hasStructure) {
+        return concatTemplates(left, right);
+      }
       return T.string;
     }
     if (isSubtypeOf(left, T.number) && isSubtypeOf(right, T.number)) {
@@ -337,6 +598,7 @@ var Ops = {
       return T.literal(typeof v);
     }
     if (operand.kind === "primitive") return T.literal(operand.type);
+    if (operand.kind === "refined") return Ops.typeof_(getRefinedBase(operand));
     if (operand.kind === "object") return T.literal("object");
     if (operand.kind === "array" || operand.kind === "tuple")
       return T.literal("object");
@@ -374,6 +636,42 @@ function applyBinaryOp(op, left, right) {
   if (!fn) return T.unknown;
   return fn(left, right);
 }
+function dispatchBinaryOp(op, left, right) {
+  if (left.kind === "refined" && left.refinement.ops?.[op]) {
+    const result = left.refinement.ops[op](left, right);
+    if (result !== void 0) return result;
+  }
+  if (right.kind === "refined" && right.refinement.ops?.[op]) {
+    const result = right.refinement.ops[op](right, left);
+    if (result !== void 0) return result;
+  }
+  const baseLeft = left.kind === "refined" ? left.base : left;
+  const baseRight = right.kind === "refined" ? right.base : right;
+  if (baseLeft !== left || baseRight !== right) {
+    return dispatchBinaryOp(op, baseLeft, baseRight);
+  }
+  return applyBinaryOp(op, left, right);
+}
+function dispatchMethod(receiver, name, args) {
+  if (receiver.kind === "refined" && receiver.refinement.methods?.[name]) {
+    const result = receiver.refinement.methods[name](receiver, args);
+    if (result !== void 0) return result;
+  }
+  if (receiver.kind === "refined") {
+    return dispatchMethod(receiver.base, name, args);
+  }
+  return void 0;
+}
+function dispatchProperty(receiver, name) {
+  if (receiver.kind === "refined" && receiver.refinement.properties?.[name]) {
+    const result = receiver.refinement.properties[name](receiver);
+    if (result !== void 0) return result;
+  }
+  if (receiver.kind === "refined") {
+    return dispatchProperty(receiver.base, name);
+  }
+  return void 0;
+}
 
 // src/environment.ts
 function createEnvironment(parent, bindings = /* @__PURE__ */ new Map()) {
@@ -426,10 +724,23 @@ export {
   Ops,
   T,
   applyBinaryOp,
+  concatTemplates,
   createEnvironment,
+  createRange,
+  createTemplate,
   deepCloneTypeValue,
+  dispatchBinaryOp,
+  dispatchMethod,
+  dispatchProperty,
+  getKnownPrefix,
+  getKnownSuffix,
   getPrimitiveTypeOf,
+  getRangeMeta,
+  getRefinedBase,
+  getTemplateParts,
+  isRange,
   isSubtypeOf,
+  isTemplate,
   mergeObjectProperties,
   narrowType,
   simplifyUnion,

package/package.json

@@ -1,11 +1,21 @@
 {
   "name": "@nudojs/core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "main": "src/index.ts",
   "exports": {
     ".": "./src/index.ts"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nudojs/nudo.git",
+    "directory": "packages/core"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org"
+  },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts"
   }