@stacksjs/stx 0.2.176 → 0.2.178

package/dist/builtins/attrs.d.ts

@@ -28,3 +28,22 @@ import type { ResolvedProps } from '../component-registry';
  * @param consumed - Prop names the builtin has already rendered itself.
  */
 export declare function forwardStaticAttrs(props: ResolvedProps, consumed: Set<string>): string[];
+/**
+ * Render the server-evaluated `:prop` bindings a builtin did not consume.
+ *
+ * Only `static` was ever forwarded, so `<StxLink to="/x" :title="pageTitle">`
+ * emitted an `<a>` with no title and no warning — the binding was resolved,
+ * stored, and thrown away (stacksjs/stx#1930). Client-reactive `:prop` and
+ * `@event` bindings already reach the element by another route (the component
+ * renderer re-applies them to the root), which is what made the gap specific to
+ * the server-evaluated ones and easy to miss.
+ *
+ * `null`, `undefined` and `false` DROP the attribute rather than rendering the
+ * word — that is what makes `:aria-current="active ? 'page' : null"` express
+ * "this attribute is conditional", which is the whole reason to reach for a
+ * binding instead of a literal. `true` renders bare, as HTML booleans do.
+ *
+ * @param props - The component's resolved props.
+ * @param consumed - Prop names the builtin has already rendered itself.
+ */
+export declare function forwardResolvedAttrs(props: ResolvedProps, consumed: Set<string>): string[];

package/dist/builtins/attrs.js

@@ -19,3 +19,21 @@ export function forwardStaticAttrs(props, consumed) {
   }
   return attrs;
 }
+export function forwardResolvedAttrs(props, consumed) {
+  const attrs = [];
+  for (const [key, value] of Object.entries(props.serverDynamic ?? {})) {
+    if (consumed.has(key))
+      continue;
+    if (value === null || value === void 0 || value === !1)
+      continue;
+    const name = props.serverDynamicNames?.[key] ?? key;
+    if (value === !0) {
+      attrs.push(escapeAttr(name));
+      continue;
+    }
+    if (typeof value === "object")
+      continue;
+    attrs.push(`${escapeAttr(name)}="${escapeAttr(stripControlChars(String(value)))}"`);
+  }
+  return attrs;
+}

package/dist/builtins/safe-image.js

@@ -1,4 +1,4 @@
-import { forwardStaticAttrs } from "./attrs.js";
+import { forwardResolvedAttrs, forwardStaticAttrs } from "./attrs.js";
 const DEFAULT_FALLBACK = "/images/safe-image-default.svg";
 function escapeAttr(value) {
   return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -34,6 +34,7 @@ export const SafeImageBuiltin = {
       "fallbackClassName"
     ]);
     imgAttrs.push(...forwardStaticAttrs(props, consumed));
+    imgAttrs.push(...forwardResolvedAttrs(props, consumed));
     const imgTag = `<img ${imgAttrs.join(" ")} />`, renderCtx = ctx.context;
     if (!renderCtx.__safeImageHandlerEmitted) {
       renderCtx.__safeImageHandlerEmitted = !0;

package/dist/builtins/stx-image.js

@@ -1,4 +1,4 @@
-import { forwardStaticAttrs } from "./attrs.js";
+import { forwardResolvedAttrs, forwardStaticAttrs } from "./attrs.js";
 const DEFAULT_BREAKPOINTS = {
   sm: 640,
   md: 768,
@@ -165,6 +165,7 @@ export const StxImageBuiltin = {
       "picture"
     ]);
     imgAttrs.push(...forwardStaticAttrs(props, consumedStatic));
+    imgAttrs.push(...forwardResolvedAttrs(props, consumedStatic));
     const imgTag = `<img ${imgAttrs.join(" ")} />`;
     let preloadTag = "";
     if (preload) {

package/dist/builtins/stx-link.js

@@ -1,4 +1,4 @@
-import { forwardStaticAttrs } from "./attrs.js";
+import { forwardResolvedAttrs, forwardStaticAttrs } from "./attrs.js";
 function escapeAttr(value) {
   return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
@@ -29,6 +29,7 @@ export const StxLinkBuiltin = {
       attrs.push("data-stx-prefetch");
     const consumedStatic = new Set(["to", "class", "className", "activeClass", "exactActiveClass", "prefetch"]);
     attrs.push(...forwardStaticAttrs(props, consumedStatic));
+    attrs.push(...forwardResolvedAttrs(props, consumedStatic));
     return `<a ${attrs.join(" ")}>${slotContent}</a>`;
   }
 };

package/dist/cli-flags.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Read a flag that may legitimately appear more than once.
+ *
+ * The CLI parser collapses repeats to the LAST value — `--lib a --lib b` arrives
+ * as the string `"b"`, and the same is true of `<path...>` and `[path...]`, so
+ * there is no option spec that expresses "repeatable". The typecheck command
+ * documented `--lib` as repeatable and had an `Array.isArray(options.lib)`
+ * branch that could therefore never run: a project splitting its ambient
+ * declarations across two files silently got whichever one it listed last
+ * (stacksjs/stx#1925, stacksjs/stx#1926).
+ *
+ * The failure points the wrong way, which is what made it expensive. Listing
+ * every declaration file — the obvious move, and what "repeatable" invites —
+ * lands on the UNHELPED baseline, because the one file that was helping got
+ * replaced by one that does not cover those names. That reads as "the flag does
+ * nothing" rather than "the flag is dropping all but one of my files", and it
+ * changes which errors are reported rather than merely how many: names that
+ * would resolve come back as `Cannot find name`, hiding the real diagnostics
+ * underneath them.
+ *
+ * So the values are read from argv, where all of them still are.
+ *
+ * @module cli-flags
+ */
+/**
+ * Every value given for `flag`, in the order written.
+ *
+ * Accepts both spellings — `--lib a` and `--lib=a` — because a user who has
+ * been told a flag repeats will reasonably try either.
+ *
+ * Values are returned verbatim; resolving them against a directory is the
+ * caller's business, since it is the caller that knows what they name.
+ */
+export declare function collectRepeatedFlag(argv: readonly string[], flag: string): string[];

package/dist/cli-flags.js

@@ -0,0 +1,20 @@
+export function collectRepeatedFlag(argv, flag) {
+  const values = [], inline = `${flag}=`;
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith(inline)) {
+      const value = arg.slice(inline.length);
+      if (value)
+        values.push(value);
+      continue;
+    }
+    if (arg === flag) {
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        values.push(next);
+        i++;
+      }
+    }
+  }
+  return values;
+}