@astryxdesign/core 0.7.2-canary.f16dc9f → 0.7.2-canary.f2b60a0

package/src/postinstall.test.mjs

@@ -11,12 +11,15 @@
  */
 
 import {describe, it, expect, beforeEach, afterEach} from 'vitest';
+import {spawnSync} from 'node:child_process';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
+import {fileURLToPath} from 'node:url';
 // Core's own package-local contract copy — what actually runs at install time.
 import {
   isAstryxInitialized,
+  isAstryxPromptInReach,
   shouldNudge,
   AGENT_DOC_PATHS,
   INIT_MARKERS,
@@ -98,6 +101,49 @@ describe('core postinstall — one authoritative source, no drift', () => {
     write('AGENTS.md', `# doc\n${MARKER}\nbody`);
     expect(isAstryxInitialized(tmp)).toBe(cliLeaf.isAstryxInitialized(tmp));
   });
+
+  it('agrees with the CLI leaf on a monorepo package', () => {
+    fs.mkdirSync(path.join(tmp, '.git'));
+    write('AGENTS.md', MARKER);
+    write('packages/app/package.json', '{"name":"app"}');
+    const app = path.join(tmp, 'packages/app');
+    expect(isAstryxPromptInReach(app)).toBe(true);
+    expect(isAstryxPromptInReach(app)).toBe(cliLeaf.isAstryxPromptInReach(app));
+  });
+});
+
+// Install time, end to end: core's real script and its contract copy, installed
+// under a monorepo's node_modules, run the way npm runs them for a package.
+describe('core postinstall — inside a monorepo package', () => {
+  const CORE = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+  const install = () => {
+    const installed = path.join(tmp, 'node_modules/@astryxdesign/core/scripts');
+    fs.mkdirSync(installed, {recursive: true});
+    for (const file of ['postinstall.mjs', 'agent-doc-state.mjs']) {
+      fs.copyFileSync(path.join(CORE, 'scripts', file), path.join(installed, file));
+    }
+    return spawnSync(process.execPath, [path.join(installed, 'postinstall.mjs')], {
+      env: {...process.env, INIT_CWD: path.join(tmp, 'packages/app'), npm_command: 'install'},
+      encoding: 'utf8',
+    });
+  };
+  beforeEach(() => {
+    fs.mkdirSync(path.join(tmp, '.git'));
+    write('packages/app/package.json', '{"name":"app"}');
+  });
+
+  it('stays quiet when init ran at the repository root', () => {
+    write('AGENTS.md', MARKER);
+    const r = install();
+    expect(r.status).toBe(0);
+    expect(r.stdout).toBe('');
+  });
+
+  it('still nudges when no folder up to the repository root ran init', () => {
+    const r = install();
+    expect(r.status).toBe(0);
+    expect(r.stdout).toMatch(/finish setup and install the Astryx agent prompt/);
+  });
 });
 
 describe('core postinstall — shouldNudge', () => {

package/src/reset.css

@@ -203,35 +203,6 @@
     height: auto;
   }
 
-  /* ===========================================================================
-     AspectRatio Fit Baseline
-     =========================================================================== */
-
-  /*
-   * Child sizing for AspectRatio's `fit` prop — the component marks the
-   * child's direct parent with `data-astryx-aspect-ratio-override` (carrying
-   * the fit value), and these direct-child rules size the child, so
-   * consumers don't hand-write width/height/object-fit on every media child.
-   * The marker sits on the parent itself, so the rules don't depend on
-   * AspectRatio's internal element structure or its theming surface. As with
-   * the [data-astryx-media] baseline below, the rules are zero-specificity
-   * and any styling the child sets itself still wins. `fit="center"` needs
-   * no rules here — the component centers the child from its own wrapper.
-   */
-  :where([data-astryx-aspect-ratio-override="cover"], [data-astryx-aspect-ratio-override="contain"])
-    > :where(*) {
-    width: 100%;
-    height: 100%;
-  }
-
-  :where([data-astryx-aspect-ratio-override="cover"]) > :where(img, video) {
-    object-fit: cover;
-  }
-
-  :where([data-astryx-aspect-ratio-override="contain"]) > :where(img, video) {
-    object-fit: contain;
-  }
-
   /* ===========================================================================
      Forms
      =========================================================================== */

package/src/theme/derivedVarRegistry.test.ts

@@ -224,9 +224,6 @@ const DIR_TO_REGISTRY_KEY: Record<string, string> = {
   Chat: 'chat',
   ContextMenu: 'context-menu',
   Dialog: 'dialog',
-  // The Drawer doc file lives in packages/lab/src/Drawer, outside this
-  // package's scan; the mapping keeps the registry orphan check honest and
-  // defineTheme.test.ts pins the expansion.
   Drawer: 'drawer',
   DropdownMenu: 'dropdown-menu',
   Field: 'field',
@@ -264,6 +261,9 @@ const CROSS_COMPONENT_VARS: Record<string, string[]> = {
   // The destructive item variant recolors the Item it renders; Item owns,
   // documents and reads both slots.
   DropdownMenu: ['--_item-label-color', '--_item-description-color'],
+  // List's edge="flush" zeroes the inline inset of the Item each ListItem
+  // renders; Item owns, documents and reads it.
+  List: ['--_item-inset-inline'],
   // A layer content root stops an outer Stepper's connector gap; Stepper owns,
   // documents and reads it.
   Layer: ['--step-connector-gap'],
@@ -319,6 +319,10 @@ const VARS_WITHOUT_DERIVED_MAPPING = new Set([
   '--tree-list-indent',
   '--_tree-indent',
   '--tree-list-row-gap',
+  // Published by each treeitem while it has keyboard focus and read as its
+  // row's z-index, so the focused row paints above the guide lines. Focus
+  // state, not a value a theme author sets.
+  '--_tree-focus-z',
   // Clipped on the ONE side each on-track connector segment faces the
   // indicator from — trailing above the node, leading below it, mirrored
   // again per axis. No standard property maps onto this purpose-based seam:

package/src/theme/derivedVarRegistry.ts

@@ -59,9 +59,6 @@ export const derivedVarRegistry: Record<string, DerivedVarEntry[]> = {
     {property: 'borderRadius', vars: ['--_dialog-radius']},
     {property: 'padding', expand: 'container'},
   ],
-  // Drawer lives in @astryxdesign/lab; its doc source of truth is
-  // packages/lab/src/Drawer/Drawer.doc.mjs, outside this package's consistency
-  // scan. defineTheme.test.ts pins the expansion instead.
   drawer: [{property: 'padding', expand: 'container'}],
   'context-menu': [
     {property: 'borderRadius', vars: ['--_dropdown-menu-radius']},

package/src/utils/focusOutline.stylex.ts

@@ -70,6 +70,10 @@ const focusOutlineLonghands = {
  * independently overridable — and every part stays a var, so a theme's
  * `--focus-outline-*` overrides still flow through.
  *
+ * NOT usable inside another file's `stylex.create`, for the same reason as
+ * {@link FOCUS_OUTLINE}: StyleX compiles each member there to a CSS variable
+ * nothing defines. Compose the `focusVars` tokens instead.
+ *
  * Keys are camelCase to match `HTMLElement.style`, so this spreads straight
  * onto an element:
  *

package/src/utils/plainDate.test.ts

@@ -1,6 +1,6 @@
 // Copyright (c) Meta Platforms, Inc. and affiliates.
 
-import {describe, it, expect} from 'vitest';
+import {describe, it, expect, afterEach} from 'vitest';
 import {
   type PlainDate,
   plainDateCreate,
@@ -711,6 +711,42 @@ describe('plainDateGetWeekNumber', () => {
     expect(plainDateGetWeekNumber({year: 2026, month: 1, day: 4})).toBe(1);
   });
 
+  // Regression: the week number must not depend on the host timezone's DST
+  // offset. Zones whose DST ends after New Year (southern hemisphere) used to
+  // add a phantom hour to the Thursday-vs-Jan-1 day count, and in years whose
+  // Jan 1 is a Friday that hour rounded a whole week up.
+  describe('DST independence', () => {
+    const originalTZ = process.env.TZ;
+
+    afterEach(() => {
+      if (originalTZ === undefined) {
+        delete process.env.TZ;
+      } else {
+        process.env.TZ = originalTZ;
+      }
+    });
+
+    it.each(['Australia/Sydney', 'Pacific/Auckland', 'America/Santiago'])(
+      'does not round week 14 up to 15 in %s (DST ends after New Year)',
+      zone => {
+        process.env.TZ = zone;
+        // 2021-01-01 is a Friday, so every ISO Thursday falls on a whole
+        // multiple of 7 days into the year. 2021-04-05..11 is ISO week 14.
+        expect(plainDateGetWeekNumber({year: 2021, month: 4, day: 5})).toBe(14);
+        expect(plainDateGetWeekNumber({year: 2021, month: 4, day: 8})).toBe(14);
+        expect(plainDateGetWeekNumber({year: 2021, month: 4, day: 11})).toBe(
+          14,
+        );
+      },
+    );
+
+    it('keeps late-December weeks correct in Australia/Sydney', () => {
+      process.env.TZ = 'Australia/Sydney';
+      // 2027-12-30 (Thursday) is ISO week 52, not 53.
+      expect(plainDateGetWeekNumber({year: 2027, month: 12, day: 30})).toBe(52);
+    });
+  });
+
   it('keeps years 1-99 instead of mapping them to 1900-1999', () => {
     // 0004-01-01 is a Thursday (ISO week 1); 1904-01-01 was a Friday.
     expect(plainDateGetWeekNumber({year: 4, month: 1, day: 1})).toBe(1);

package/src/utils/plainDate.ts

@@ -282,11 +282,21 @@ export function plainDateSetEndOfWeekExclusive(
 }
 
 export function plainDateGetWeekNumber(pd: PlainDate): number {
-  const d = plainDateToDate(pd);
-  const dayNum = d.getDay() || 7;
-  d.setDate(d.getDate() + 4 - dayNum);
-  const yearStart = plainDateToDate({year: d.getFullYear(), month: 1, day: 1});
-  return Math.ceil(((d.getTime() - yearStart.getTime()) / 86400000 + 1) / 7);
+  // ISO week number: ceil(day-of-year of the week's Thursday / 7). Computed
+  // entirely on UTC anchors — the same DST immunity plainDateDiffDays relies
+  // on — because mixing local-time instants leaks the host zone's DST offset
+  // into the day count. When Jan 1 is a Friday (so every Thursday's day-of-year
+  // is an exact multiple of 7), a one-hour offset from a zone whose DST ends
+  // after New Year rounds a whole week up: Sydney, Auckland and Santiago users
+  // saw week 15 for the week that is ISO week 14. utcTime keeps years 1-99
+  // as given, like the other Calendar date helpers.
+  const msPerDay = 24 * 60 * 60 * 1000;
+  const utcMidnight = utcTime(pd.year, pd.month - 1, pd.day);
+  const dayNum = new Date(utcMidnight).getUTCDay() || 7;
+  const thursday = utcMidnight + (4 - dayNum) * msPerDay;
+  const yearStart = utcTime(new Date(thursday).getUTCFullYear(), 0, 1);
+  const dayOfYear = (thursday - yearStart) / msPerDay + 1;
+  return Math.ceil(dayOfYear / 7);
 }
 
 // e.g. "Wednesday, May 21, 2026" (locale-dependent)

package/src/utils/sharedMutationObserver.test.ts

@@ -0,0 +1,53 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import {describe, it, expect, vi} from 'vitest';
+import {observeContent} from './sharedMutationObserver';
+
+const flush = async () => new Promise(resolve => setTimeout(resolve, 0));
+
+describe('observeContent', () => {
+  it('calls a registration once per batch for changes anywhere inside its element', async () => {
+    const element = document.createElement('div');
+    element.innerHTML = '<span>first</span>';
+    const callback = vi.fn();
+    const unsubscribe = observeContent(element, callback);
+
+    element.querySelector('span')!.firstChild!.nodeValue = 'second';
+    element.append('third');
+    await flush();
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    unsubscribe();
+  });
+
+  it('removes only its own registration', async () => {
+    const element = document.createElement('div');
+    const kept = vi.fn();
+    const removed = vi.fn();
+    const unsubscribeKept = observeContent(element, kept);
+    const unsubscribeRemoved = observeContent(element, removed);
+
+    unsubscribeRemoved();
+    element.textContent = 'changed';
+    await flush();
+
+    expect(kept).toHaveBeenCalledTimes(1);
+    expect(removed).not.toHaveBeenCalled();
+    unsubscribeKept();
+  });
+
+  it('ignores a released element', async () => {
+    const released = document.createElement('div');
+    const live = document.createElement('div');
+    const releasedCallback = vi.fn();
+    const unsubscribeReleased = observeContent(released, releasedCallback);
+    const unsubscribeLive = observeContent(live, vi.fn());
+
+    unsubscribeReleased();
+    released.textContent = 'changed';
+    await flush();
+
+    expect(releasedCallback).not.toHaveBeenCalled();
+    unsubscribeLive();
+  });
+});

package/src/utils/sharedMutationObserver.ts

@@ -0,0 +1,78 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+'use client';
+
+/**
+ * @file sharedMutationObserver.ts
+ * @input MutationObserver API
+ * @output Exports observeContent for shared content-change observation
+ * @position Internal utility; consumed by useTruncation. The content-change
+ *   counterpart of sharedResizeObserver: one observer for every element, so a
+ *   repeated cell or row path does not create one observer per instance.
+ */
+
+type ContentCallback = () => void;
+
+const OPTIONS: MutationObserverInit = {
+  characterData: true,
+  childList: true,
+  subtree: true,
+};
+
+let observer: MutationObserver | null = null;
+const callbacks = new Map<Node, Set<ContentCallback>>();
+
+function dispatch(records: MutationRecord[]): void {
+  // One call per callback per batch, however many records it received. A
+  // record's target can be any descendant, so walk up to the observed roots.
+  const pending = new Set<ContentCallback>();
+  for (const record of records) {
+    for (let node: Node | null = record.target; node; node = node.parentNode) {
+      callbacks.get(node)?.forEach(callback => pending.add(callback));
+    }
+  }
+  pending.forEach(callback => callback());
+}
+
+/**
+ * Call `callback` when the element's text or children change (including
+ * descendants). Returns an unsubscribe that removes only this registration.
+ *
+ * MutationObserver has no per-target unobserve, so a released element stays
+ * registered with the shared observer until no element remains; its records
+ * match no callback and are ignored. The observer disconnects and is released
+ * when the last registration goes.
+ */
+export function observeContent(
+  element: Element,
+  callback: ContentCallback,
+): () => void {
+  if (typeof MutationObserver === 'undefined') {
+    return () => {};
+  }
+  observer ??= new MutationObserver(dispatch);
+  const existing = callbacks.get(element);
+  if (existing) {
+    existing.add(callback);
+  } else {
+    callbacks.set(element, new Set([callback]));
+    observer.observe(element, OPTIONS);
+  }
+
+  let isSubscribed = true;
+  return () => {
+    if (!isSubscribed) {
+      return;
+    }
+    isSubscribed = false;
+    const targetCallbacks = callbacks.get(element);
+    targetCallbacks?.delete(callback);
+    if (targetCallbacks?.size === 0) {
+      callbacks.delete(element);
+    }
+    if (callbacks.size === 0 && observer) {
+      observer.disconnect();
+      observer = null;
+    }
+  };
+}