@rettangoli/check 0.1.1 → 0.1.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yuusoft
+
+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/README.md

@@ -15,7 +15,7 @@ Implemented now:
 - package + CLI entrypoint (`@rettangoli/check`, `rtgl check`)
 - discovery and component grouping
 - model building for YAML/JS contracts
-- FE parity checks (schema required, forbidden view keys, legacy `.prop=` binding)
+- FE parity checks (schema required, forbidden view keys, unsupported property binding syntax)
 - schema/constants checks
 - listener config checks
 - strict handler naming checks (`handle*` only)
@@ -112,7 +112,7 @@ Current baseline is clean in strict mode:
 
 - required `.schema.yaml` per component
 - forbidden metadata keys inside `.view.yaml`
-- legacy `.prop=` syntax detection
+- unsupported property binding syntax detection
 
 That baseline is good, but many contract violations are still caught late (during build, runtime, or manually).
 

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "@rettangoli/check",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "Static contract checker for Rettangoli projects",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yuusoft-org/rettangoli",
+    "directory": "packages/rettangoli-check"
+  },
   "main": "./src/index.js",
   "exports": {
     ".": "./src/index.js",
@@ -12,12 +17,16 @@
     "rtgl-check": "./src/cli/bin.js"
   },
   "scripts": {
+    "ci": "npm run test:no-fe-contracts-import && npm run test:ui-registry-resolution-contract && npm run test:scenarios",
+    "test:package": "node ./scripts/package-smoke-test.js",
     "test:scenarios": "node ./test/run-scenarios.js",
+    "test:no-fe-contracts-import": "node ./scripts/test-no-fe-contracts-import.js",
     "test:diff-js-exports": "node ./scripts/differential-js-exports.js",
     "test:fuzz-template-pipeline": "node ./scripts/fuzz-template-pipeline.js",
     "test:fuzz-jempl-parser": "node ./scripts/fuzz-jempl-parser.js",
     "test:jempl-parser-contract": "node ./scripts/test-jempl-parser-contract.js",
     "test:scope-graph-range-contract": "node ./scripts/test-scope-graph-range-contract.js",
+    "test:ui-registry-resolution-contract": "node ./scripts/test-ui-registry-resolution-contract.js",
     "test:fe-frontend-component-identity-contract": "node ./scripts/test-fe-frontend-component-identity-contract.js",
     "test:fe-frontend-handler-contract": "node ./scripts/test-fe-frontend-handler-contract.js",
     "test:fe-frontend-lifecycle-contract": "node ./scripts/test-fe-frontend-lifecycle-contract.js",
@@ -33,11 +42,12 @@
   "files": [
     "src",
     "README.md",
-    "ROADMAP.md"
+    "ROADMAP.md",
+    "LICENSE"
   ],
   "license": "MIT",
   "dependencies": {
-    "@rettangoli/fe": "1.0.0-rc3",
+    "@rettangoli/ui": "1.11.0",
     "jempl": "0.3.2-rc2",
     "js-yaml": "^4.1.0",
     "oxc-parser": "^0.112.0",

package/src/core/fe-contracts.js

@@ -0,0 +1,212 @@
+const PROP_PREFIX = ":";
+
+const REF_ID_KEY_REGEX = /^[a-z][a-zA-Z0-9]*\*?$/;
+const REF_CLASS_KEY_REGEX = /^[a-zA-Z][a-zA-Z0-9_-]*\*?$/;
+const REF_ID_REGEX = /^[a-z][a-zA-Z0-9]*$/;
+const GLOBAL_REF_KEYS = new Set(["window", "document"]);
+
+export const collectBindingNames = (attrsString = "") => {
+  if (!attrsString) {
+    return [];
+  }
+
+  const attrAssignmentRegex = /(\S+?)=(?:\"([^\"]*)\"|\'([^\']*)\'|([^\s]*))/g;
+  const booleanAttrRegex = /\b(\S+?)(?=\s|$)/g;
+  const processedAttrs = new Set();
+  const bindingNames = [];
+  let match;
+
+  while ((match = attrAssignmentRegex.exec(attrsString)) !== null) {
+    const rawBindingName = match[1];
+    processedAttrs.add(rawBindingName);
+    bindingNames.push(rawBindingName);
+  }
+  attrAssignmentRegex.lastIndex = 0;
+
+  let remainingAttrsString = attrsString;
+  const processedMatches = [];
+  while ((match = attrAssignmentRegex.exec(attrsString)) !== null) {
+    processedMatches.push(match[0]);
+  }
+
+  processedMatches.forEach((processedMatch) => {
+    remainingAttrsString = remainingAttrsString.replace(processedMatch, " ");
+  });
+
+  let boolMatch;
+  while ((boolMatch = booleanAttrRegex.exec(remainingAttrsString)) !== null) {
+    const attrName = boolMatch[1];
+    if (attrName.startsWith(".")) {
+      continue;
+    }
+    if (
+      !processedAttrs.has(attrName)
+      && !attrName.startsWith(PROP_PREFIX)
+      && !attrName.includes("=")
+    ) {
+      bindingNames.push(attrName);
+    }
+  }
+
+  return [...new Set(bindingNames)];
+};
+
+export const createRefMatchers = (refs) => {
+  return Object.entries(refs || {}).map(([refKey, refConfig]) => {
+    if (GLOBAL_REF_KEYS.has(refKey)) {
+      return {
+        refKey,
+        refConfig,
+        targetType: "global",
+        isWildcard: false,
+        prefix: refKey,
+      };
+    }
+
+    let targetType = "id";
+    let rawKey = refKey;
+    if (refKey.startsWith(".")) {
+      targetType = "class";
+      rawKey = refKey.slice(1);
+    } else if (refKey.startsWith("#")) {
+      targetType = "id";
+      rawKey = refKey.slice(1);
+    }
+
+    const reservedBaseKey = rawKey.endsWith("*") ? rawKey.slice(0, -1) : rawKey;
+    if (GLOBAL_REF_KEYS.has(reservedBaseKey)) {
+      throw new Error(
+        `[Parser] Invalid ref key '${refKey}'. Reserved global keys must be exactly 'window' or 'document'.`,
+      );
+    }
+
+    if (targetType === "id" && !REF_ID_KEY_REGEX.test(rawKey)) {
+      throw new Error(
+        `[Parser] Invalid ref key '${refKey}'. Use camelCase IDs (optional '#', optional '*') or class refs with '.' prefix.`,
+      );
+    }
+    if (targetType === "class" && !REF_CLASS_KEY_REGEX.test(rawKey)) {
+      throw new Error(
+        `[Parser] Invalid ref key '${refKey}'. Class refs must start with '.' and use class-compatible names (optional '*').`,
+      );
+    }
+
+    const isWildcard = rawKey.endsWith("*");
+    const prefix = isWildcard ? rawKey.slice(0, -1) : rawKey;
+
+    return {
+      refKey,
+      refConfig,
+      targetType,
+      isWildcard,
+      prefix,
+    };
+  });
+};
+
+export const validateElementIdForRefs = (elementIdForRefs) => {
+  if (!REF_ID_REGEX.test(elementIdForRefs)) {
+    throw new Error(
+      `[Parser] Invalid element id '${elementIdForRefs}' for refs. Use camelCase ids only. Kebab-case ids are not supported.`,
+    );
+  }
+};
+
+const assertBooleanEventOption = ({ optionName, optionValue, eventType, refKey }) => {
+  if (optionValue === undefined) {
+    return;
+  }
+  if (typeof optionValue !== "boolean") {
+    throw new Error(
+      `[Parser] Invalid '${optionName}' for event '${eventType}' on ref '${refKey}'. Expected boolean.`,
+    );
+  }
+};
+
+const assertNumberEventOption = ({ optionName, optionValue, eventType, refKey }) => {
+  if (optionValue === undefined) {
+    return;
+  }
+  if (
+    typeof optionValue !== "number"
+    || Number.isNaN(optionValue)
+    || !Number.isFinite(optionValue)
+    || optionValue < 0
+  ) {
+    throw new Error(
+      `[Parser] Invalid '${optionName}' for event '${eventType}' on ref '${refKey}'. Expected non-negative number.`,
+    );
+  }
+};
+
+export const validateEventConfig = ({ eventType, eventConfig, refKey }) => {
+  if (typeof eventConfig !== "object" || eventConfig === null) {
+    throw new Error(
+      `[Parser] Invalid event config for event '${eventType}' on ref '${refKey}'.`,
+    );
+  }
+
+  const hasDebounce = Object.prototype.hasOwnProperty.call(eventConfig, "debounce");
+  const hasThrottle = Object.prototype.hasOwnProperty.call(eventConfig, "throttle");
+
+  assertBooleanEventOption({
+    optionName: "preventDefault",
+    optionValue: eventConfig.preventDefault,
+    eventType,
+    refKey,
+  });
+  assertBooleanEventOption({
+    optionName: "stopPropagation",
+    optionValue: eventConfig.stopPropagation,
+    eventType,
+    refKey,
+  });
+  assertBooleanEventOption({
+    optionName: "stopImmediatePropagation",
+    optionValue: eventConfig.stopImmediatePropagation,
+    eventType,
+    refKey,
+  });
+  assertBooleanEventOption({
+    optionName: "targetOnly",
+    optionValue: eventConfig.targetOnly,
+    eventType,
+    refKey,
+  });
+  assertBooleanEventOption({
+    optionName: "once",
+    optionValue: eventConfig.once,
+    eventType,
+    refKey,
+  });
+  assertNumberEventOption({
+    optionName: "debounce",
+    optionValue: eventConfig.debounce,
+    eventType,
+    refKey,
+  });
+  assertNumberEventOption({
+    optionName: "throttle",
+    optionValue: eventConfig.throttle,
+    eventType,
+    refKey,
+  });
+
+  if (hasDebounce && hasThrottle) {
+    throw new Error(
+      `[Parser] Event '${eventType}' on ref '${refKey}' cannot define both 'debounce' and 'throttle'.`,
+    );
+  }
+
+  if (eventConfig.handler && eventConfig.action) {
+    throw new Error("Each listener can have handler or action but not both");
+  }
+  if (!eventConfig.handler && !eventConfig.action) {
+    throw new Error("Each listener must define either handler or action");
+  }
+
+  return {
+    hasDebounce,
+    hasThrottle,
+  };
+};

package/src/core/parsers.js

@@ -1,6 +1,6 @@
 import { load as loadYaml } from "js-yaml";
 import { parseSync } from "oxc-parser";
-import { collectBindingNames as collectFeBindingNames } from "@rettangoli/fe/contracts";
+import { collectBindingNames as collectFeBindingNames } from "./fe-contracts.js";
 import { parse as parseJempl } from "jempl";
 import { parseElementKey as parseYahtmlElementKey } from "yahtml";
 

package/src/core/registry.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { load as loadYaml } from "js-yaml";
 import { parseSync } from "oxc-parser";
@@ -713,6 +714,61 @@ const resolveBundledUiDir = () => {
   return path.resolve(currentDir, "../../../rettangoli-ui");
 };
 
+const isUiSourceDir = (candidate) => {
+  if (!candidate) {
+    return false;
+  }
+
+  const packageJsonPath = path.join(candidate, "package.json");
+  const componentsDir = path.join(candidate, "src", "components");
+  const entryPath = path.join(candidate, "src", "entry-iife-ui.js");
+  if (!existsSync(packageJsonPath) || !existsSync(componentsDir) || !existsSync(entryPath)) {
+    return false;
+  }
+
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return packageJson?.name === "@rettangoli/ui";
+  } catch {
+    return false;
+  }
+};
+
+const findUiPackageDir = (resolvedEntryPath) => {
+  let currentDir = path.dirname(resolvedEntryPath);
+  const filesystemRoot = path.parse(currentDir).root;
+
+  while (currentDir !== filesystemRoot) {
+    if (isUiSourceDir(currentDir)) {
+      return currentDir;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+
+  return null;
+};
+
+const resolveInstalledUiDir = (baseDir) => {
+  try {
+    const require = createRequire(path.join(path.resolve(baseDir), "package.json"));
+    return findUiPackageDir(require.resolve("@rettangoli/ui"));
+  } catch {
+    return null;
+  }
+};
+
+export const resolveUiSourceDir = ({ workspaceRoot = process.cwd() } = {}) => {
+  const candidates = [
+    path.resolve(workspaceRoot),
+    path.resolve(workspaceRoot, "packages", "rettangoli-ui"),
+    resolveBundledUiDir(),
+    resolveInstalledUiDir(workspaceRoot),
+    resolveInstalledUiDir(path.dirname(fileURLToPath(import.meta.url))),
+  ];
+
+  return [...new Set(candidates.filter(Boolean))].find(isUiSourceDir) || null;
+};
+
 const collectPrimitiveContractsFromEntries = async ({ uiDir, globalStyleAttrs }) => {
   const result = new Map();
   const entryNames = ["entry-iife-ui.js", "entry-iife-layout.js"];
@@ -729,12 +785,7 @@ const collectPrimitiveContractsFromEntries = async ({ uiDir, globalStyleAttrs })
 };
 
 export const buildUiRegistry = async ({ workspaceRoot = process.cwd() } = {}) => {
-  const uiCandidates = [
-    path.resolve(workspaceRoot, "packages", "rettangoli-ui"),
-    resolveBundledUiDir(),
-  ];
-
-  const uiDir = uiCandidates.find((candidate) => existsSync(candidate));
+  const uiDir = resolveUiSourceDir({ workspaceRoot });
   if (!uiDir) {
     return new Map();
   }

package/src/diagnostics/catalog.js

@@ -30,7 +30,7 @@ const CATALOG_VERSION = 1;
 const CODE_OVERRIDES = {
   "RTGL-CONTRACT-003": {
     title: "Legacy dot-prop binding",
-    description: "Legacy '.prop=' template bindings are unsupported and should be converted to ':prop='.",
+    description: "Legacy property binding syntax is unsupported; property bindings must use ':prop=${...}' in source templates.",
     tags: ["autofix-safe", "template"],
   },
   "RTGL-CHECK-YAHTML-002": {

package/src/rules/feParity.js

@@ -45,7 +45,7 @@ export const runFeParityRules = ({ models = [] }) => {
         severity: "error",
         filePath: viewPath,
         line: model.view.legacyDotPropBindingLine,
-        message: `${model.componentKey}: legacy '.prop=' binding is not supported. Use ':prop=' in .view.yaml.`,
+        message: `${model.componentKey}: legacy property binding syntax is not supported. Use ':prop=\${value}' in .view.yaml.`,
         fix: {
           kind: "line-regex-replace",
           filePath: viewPath,
@@ -53,7 +53,7 @@ export const runFeParityRules = ({ models = [] }) => {
           pattern: "\\.([a-zA-Z][\\w-]*)\\s*=",
           replacement: ":$1=",
           flags: "g",
-          description: "Convert legacy '.prop=' binding to ':prop='.",
+          description: "Convert legacy '.prop=' prefix to ':prop='; wrap bare values in '${...}' if needed.",
           safe: true,
           confidence: 0.98,
         },

package/src/rules/listenerConfig.js

@@ -9,7 +9,7 @@ import { getModelFilePath, getYamlPathLine, isObjectRecord } from "./shared.js";
 import {
   validateElementIdForRefs,
   validateEventConfig as validateFeEventConfig,
-} from "@rettangoli/fe/contracts";
+} from "../core/fe-contracts.js";
 import { parseSync } from "oxc-parser";
 import { parseNamedExportedFunctions } from "../core/exportedFunctions.js";
 const GLOBAL_REF_KEYS = new Set(["window", "document"]);

package/src/rules/refs.js

@@ -1,4 +1,4 @@
-import { createRefMatchers } from "@rettangoli/fe/contracts";
+import { createRefMatchers } from "../core/fe-contracts.js";
 import { isObjectRecord } from "./shared.js";
 
 export const collectInvalidRefKeys = (refs) => {