@astryxdesign/cli 0.6.4-canary.f0355e3 → 0.6.4

package/api/discover/_catalog-view.mjs

@@ -1,203 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file Pure views over discover sources' catalogs: which catalog packages the
- * project already has, what it could add, and the items search looks through.
- * No I/O; the adapter supplies every input.
- *
- * @position api/discover — shared by the list, detail, item, and search leaves.
- */
-
-import {KIND_FIELDS} from './_adapter.mjs';
-
-/**
- * @typedef {import('./_adapter.mjs').InstalledPackage} InstalledPackage
- * @typedef {import('./_adapter.mjs').CatalogResult} CatalogResult
- * @typedef {CatalogResult['packages'][number]} CatalogPackage
- * @typedef {import('../../authoring/discover/type').DiscoverKind} DiscoverKind
- */
-
-/**
- * An item search looks through. `kind: 'package'` is a package itself.
- * @typedef {object} SearchItem
- * @property {string} package
- * @property {DiscoverKind | 'package'} kind
- * @property {string} name
- * @property {boolean} installed
- * @property {string} [title]
- * @property {string} [summary]
- * @property {string[]} [keywords]
- * @property {string} [description]
- */
-
-/**
- * Group a version's contributions into the entry fields, one list per kind.
- * `components` is always present, like on an installed entry.
- * @param {CatalogPackage['contributions']} contributions
- * @returns {Record<string, string[]>}
- */
-export function kindLists(contributions) {
-  /** @type {Record<string, string[]>} */
-  const lists = {components: []};
-  for (const [kind, field] of KIND_FIELDS) {
-    const names = contributions.filter(c => c.kind === kind).map(c => c.name);
-    if (names.length > 0 || field === 'components') lists[field] = names;
-  }
-  return lists;
-}
-
-/**
- * Whether an entry adds at least one item of `kind`.
- * @param {Record<string, unknown>} entry
- * @param {DiscoverKind} kind
- * @returns {boolean}
- */
-export function hasKind(entry, kind) {
-  const field = KIND_FIELDS.find(([k]) => k === kind)?.[1];
-  const values = field == null ? undefined : entry[field];
-  return Array.isArray(values) && values.length > 0;
-}
-
-/**
- * Where a catalog package stands against the project.
- * @param {CatalogPackage} pkg
- * @param {Set<string>} installedNames
- * @param {Set<string>} declared
- * @returns {{state: 'installed' | 'declared' | 'alias' | 'available', installedAs?: string}}
- */
-export function catalogState(pkg, installedNames, declared) {
-  if (installedNames.has(pkg.package)) return {state: 'installed'};
-  if (declared.has(pkg.package)) return {state: 'declared'};
-  const installedAs = pkg.aliases.find(
-    name => installedNames.has(name) || declared.has(name),
-  );
-  if (installedAs != null) return {state: 'alias', installedAs};
-  return {state: 'available'};
-}
-
-/**
- * The version a catalog package shows by default.
- * @param {CatalogPackage} pkg
- * @returns {string | undefined}
- */
-export function defaultVersion(pkg) {
-  return pkg.latest ?? pkg.versions[0]?.version;
-}
-
-/**
- * Project a catalog package into the entry shape installed packages use.
- * @param {CatalogPackage} pkg
- * @param {string | undefined} version
- */
-export function catalogEntry(pkg, version) {
-  const {components, ...others} = kindLists(pkg.contributions);
-  return {
-    name: pkg.package,
-    category: pkg.package,
-    components,
-    ...(version ? {version} : {}),
-    ...(pkg.description ? {description: pkg.description} : {}),
-    ...others,
-  };
-}
-
-/**
- * What the project could add: every catalog package it does not have, once per
- * integration (the first name a source lists), never an alias of one it has.
- * @param {CatalogResult} catalog
- * @param {InstalledPackage[]} installed
- * @param {Set<string>} declared
- */
-export function availableEntries(catalog, installed, declared) {
-  const installedNames = new Set(installed.map(p => p.name));
-  /** @type {Set<string>} */
-  const integrations = new Set();
-  const entries = [];
-  for (const pkg of catalog.packages) {
-    if (catalogState(pkg, installedNames, declared).state !== 'available')
-      continue;
-    if (integrations.has(pkg.integration)) continue;
-    integrations.add(pkg.integration);
-    const version = defaultVersion(pkg);
-    const {category: _category, ...entry} = catalogEntry(pkg, version);
-    entries.push({
-      ...entry,
-      ...(pkg.aliases.length > 0 ? {aliases: pkg.aliases} : {}),
-      source: pkg.source,
-    });
-  }
-  return entries;
-}
-
-/**
- * Installed packages with the latest release a source knows for each.
- * @param {InstalledPackage[]} installed
- * @param {CatalogResult} catalog
- * @returns {Array<InstalledPackage & {latest?: string}>}
- */
-export function withLatest(installed, catalog) {
-  const byName = new Map(catalog.packages.map(p => [p.package, p]));
-  return installed.map(pkg => {
-    const latest = byName.get(pkg.name)?.latest;
-    return latest ? {...pkg, latest} : pkg;
-  });
-}
-
-/**
- * Everything search looks through besides installed components (which the
- * search leaf keeps resolving the way it always has): installed packages and
- * their other items, and every package the project could add with its items.
- * @param {InstalledPackage[]} installed
- * @param {CatalogResult} catalog
- * @param {Set<string>} declared
- * @returns {SearchItem[]}
- */
-export function searchItems(installed, catalog, declared) {
-  /** @type {SearchItem[]} */
-  const items = [];
-  for (const pkg of installed) {
-    items.push({
-      package: pkg.name,
-      kind: 'package',
-      name: pkg.name,
-      installed: true,
-      ...(pkg.description ? {description: pkg.description} : {}),
-    });
-    for (const [kind, field] of KIND_FIELDS) {
-      if (kind === 'component') continue;
-      const names = /** @type {Record<string, unknown>} */ (pkg)[field];
-      if (!Array.isArray(names)) continue;
-      for (const name of names) {
-        items.push({package: pkg.name, kind, name, installed: true});
-      }
-    }
-  }
-  const installedNames = new Set(installed.map(p => p.name));
-  /** @type {Set<string>} */
-  const integrations = new Set();
-  for (const pkg of catalog.packages) {
-    if (catalogState(pkg, installedNames, declared).state !== 'available')
-      continue;
-    if (integrations.has(pkg.integration)) continue;
-    integrations.add(pkg.integration);
-    items.push({
-      package: pkg.package,
-      kind: 'package',
-      name: pkg.package,
-      installed: false,
-      ...(pkg.description ? {description: pkg.description} : {}),
-    });
-    for (const c of pkg.contributions) {
-      items.push({
-        package: pkg.package,
-        kind: c.kind,
-        name: c.name,
-        installed: false,
-        ...(c.title ? {title: c.title} : {}),
-        ...(c.summary ? {summary: c.summary} : {}),
-        ...(c.keywords ? {keywords: c.keywords} : {}),
-      });
-    }
-  }
-  return items;
-}

package/api/discover/_catalog-view.test.mjs

@@ -1,128 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file Tests for the pure views over discover sources' catalogs.
- */
-
-import {describe, expect, it} from 'vitest';
-import {
-  availableEntries,
-  catalogState,
-  kindLists,
-  searchItems,
-  withLatest,
-} from './_catalog-view.mjs';
-
-/**
- * @param {string} name
- * @param {string} integration
- * @param {object} [extra]
- * @returns {any}
- */
-function entry(name, integration, extra = {}) {
-  return {
-    package: name,
-    integration,
-    aliases: [],
-    latest: '1.0.0',
-    versions: [],
-    contributions: [{kind: 'component', name: 'A'}],
-    source: 'S',
-    ...extra,
-  };
-}
-
-const CATALOG = {
-  sources: [],
-  packages: [
-    entry('@acme/ui', 'acme-ui', {aliases: ['@acme/ui-classic']}),
-    entry('@acme/ui-classic', 'acme-ui', {aliases: ['@acme/ui']}),
-    entry('@acme/charts', 'charts', {
-      latest: '2.0.0',
-      contributions: [{kind: 'theme', name: 'ocean'}],
-    }),
-  ],
-};
-
-/** @param {string} name @returns {any} */
-const installed = name => ({name, category: name, components: []});
-
-describe('availableEntries', () => {
-  it('offers each integration once, under the first name a source lists', () => {
-    expect(
-      availableEntries(CATALOG, [], new Set()).map(e => [e.name, e.aliases]),
-    ).toEqual([
-      ['@acme/ui', ['@acme/ui-classic']],
-      ['@acme/charts', undefined],
-    ]);
-  });
-
-  it('never offers an integration the project has under another name', () => {
-    expect(
-      availableEntries(CATALOG, [installed('@acme/ui-classic')], new Set()).map(
-        e => e.name,
-      ),
-    ).toEqual(['@acme/charts']);
-  });
-
-  it('does not offer a package the project declares, even when it did not load', () => {
-    expect(
-      availableEntries(CATALOG, [], new Set(['@acme/charts'])).map(e => e.name),
-    ).toEqual(['@acme/ui']);
-  });
-
-  it('describes an entry the way an installed one is described', () => {
-    expect(availableEntries(CATALOG, [], new Set())[1]).toEqual({
-      name: '@acme/charts',
-      components: [],
-      version: '2.0.0',
-      themes: ['ocean'],
-      source: 'S',
-    });
-  });
-});
-
-describe('catalogState', () => {
-  it('names the package the project has instead', () => {
-    expect(
-      catalogState(CATALOG.packages[0], new Set(['@acme/ui-classic']), new Set()),
-    ).toEqual({state: 'alias', installedAs: '@acme/ui-classic'});
-  });
-});
-
-describe('withLatest', () => {
-  it('adds the latest release a source knows to an installed package', () => {
-    expect(withLatest([installed('@acme/charts')], CATALOG)[0]).toMatchObject({
-      latest: '2.0.0',
-    });
-  });
-});
-
-describe('kindLists', () => {
-  it('groups items by kind, always with components', () => {
-    expect(
-      kindLists([
-        {kind: 'theme', name: 'ocean'},
-        {kind: 'component', name: 'A'},
-      ]),
-    ).toEqual({components: ['A'], themes: ['ocean']});
-  });
-});
-
-describe('searchItems', () => {
-  it('covers installed packages and their other items, then what could be added', () => {
-    const items = searchItems(
-      [{...installed('@acme/widgets'), templates: ['pages/Home']}],
-      CATALOG,
-      new Set(),
-    );
-    expect(items.map(i => [i.package, i.kind, i.name, i.installed])).toEqual([
-      ['@acme/widgets', 'package', '@acme/widgets', true],
-      ['@acme/widgets', 'template', 'pages/Home', true],
-      ['@acme/ui', 'package', '@acme/ui', false],
-      ['@acme/ui', 'component', 'A', false],
-      ['@acme/charts', 'package', '@acme/charts', false],
-      ['@acme/charts', 'theme', 'ocean', false],
-    ]);
-  });
-});

package/api/discover/detail/item/item.d.mts

@@ -1,26 +0,0 @@
-// @generated by scripts/sync-api-types.mjs from the JSDoc in api/**/*.mjs.
-// DO NOT EDIT — run `pnpm sync:api-types` to regenerate.
-
-/**
- * Find one item of a package: an installed package's own templates, docs,
- * themes, and codemods first, then what a discover source lists for the
- * package. Returns null when neither has it, so the caller can report the
- * component lookup's own error.
- *
- * @param {import('../../_adapter.mjs').InstalledPackage[]} packages
- * @param {string} packageName
- * @param {string} itemName
- * @param {{
- *   catalog?: import('../../_catalog-view.mjs').CatalogPackage,
- *   version?: string,
- *   add?: (name: string, version?: string) => string,
- *   installedAs?: string,
- * }} [options]
- * @returns {import('../../discover.type.mjs').DiscoverItemResponse | null}
- */
-export function item(packages: import("../../_adapter.mjs").InstalledPackage[], packageName: string, itemName: string, options?: {
-    catalog?: import("../../_catalog-view.mjs").CatalogPackage;
-    version?: string;
-    add?: (name: string, version?: string) => string;
-    installedAs?: string;
-}): import("../../discover.type.mjs").DiscoverItemResponse | null;

package/api/discover/detail/item/item.mjs

@@ -1,78 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file discover.item leaf — one item a package adds, when it is not an
- * installed component (those keep resolving to their full doc through
- * ../doc).
- *
- * @position api/discover/detail/item — pure projection over the packages and
- *   catalog entry resolved by ../../_adapter.
- */
-
-import {KIND_FIELDS} from '../../_adapter.mjs';
-import {defaultVersion} from '../../_catalog-view.mjs';
-
-/**
- * Find one item of a package: an installed package's own templates, docs,
- * themes, and codemods first, then what a discover source lists for the
- * package. Returns null when neither has it, so the caller can report the
- * component lookup's own error.
- *
- * @param {import('../../_adapter.mjs').InstalledPackage[]} packages
- * @param {string} packageName
- * @param {string} itemName
- * @param {{
- *   catalog?: import('../../_catalog-view.mjs').CatalogPackage,
- *   version?: string,
- *   add?: (name: string, version?: string) => string,
- *   installedAs?: string,
- * }} [options]
- * @returns {import('../../discover.type.mjs').DiscoverItemResponse | null}
- */
-export function item(packages, packageName, itemName, options = {}) {
-  const {catalog, version, add, installedAs} = options;
-  const pkg = packages.find(p => p.name === packageName);
-  if (pkg && (!version || version === pkg.version)) {
-    for (const [kind, field] of KIND_FIELDS) {
-      if (kind === 'component') continue;
-      const names = /** @type {Record<string, unknown>} */ (pkg)[field];
-      if (Array.isArray(names) && names.includes(itemName)) {
-        return {
-          type: 'discover.item',
-          data: {
-            package: packageName,
-            ...(pkg.version ? {version: pkg.version} : {}),
-            kind,
-            name: itemName,
-            installed: true,
-          },
-        };
-      }
-    }
-  }
-
-  const lower = itemName.toLowerCase();
-  const found =
-    catalog?.contributions.find(c => c.name === itemName) ??
-    catalog?.contributions.find(c => c.name.toLowerCase() === lower);
-  if (!catalog || !found) return null;
-  const shown = version ?? defaultVersion(catalog);
-  return {
-    type: 'discover.item',
-    data: {
-      package: packageName,
-      ...(shown ? {version: shown} : {}),
-      kind: found.kind,
-      name: found.name,
-      ...(found.title ? {title: found.title} : {}),
-      ...(found.summary ? {summary: found.summary} : {}),
-      ...(found.keywords ? {keywords: found.keywords} : {}),
-      installed: pkg != null,
-      ...(pkg == null && installedAs ? {installedAs} : {}),
-      ...(pkg == null && !installedAs && add
-        ? {install: add(packageName, version)}
-        : {}),
-      source: catalog.source,
-    },
-  };
-}

package/api/discover/detail/item/item.test.mjs

@@ -1,73 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file Tests for the discover.item leaf, a pure projection over installed
- * packages and a source's catalog entry.
- */
-
-import {describe, expect, it} from 'vitest';
-import {item} from './item.mjs';
-
-/** @type {any[]} */
-const PACKAGES = [
-  {
-    name: '@acme/widgets',
-    category: '@acme/widgets',
-    version: '1.2.3',
-    components: ['Alpha'],
-    templates: ['pages/Home'],
-    docs: ['guide'],
-  },
-];
-
-/** @type {any} */
-const CATALOG = {
-  package: '@acme/charts',
-  integration: 'acme-charts',
-  aliases: [],
-  latest: '2.0.0',
-  source: 'Acme',
-  versions: [],
-  contributions: [{kind: 'template', name: 'pages/Report', title: 'Report page'}],
-};
-
-/** @param {string} name @param {string} [version] */
-const add = (name, version) => `pnpm add ${version ? `${name}@${version}` : name}`;
-
-describe('discover.item leaf', () => {
-  it("finds an installed package's own template, doc, theme, or codemod", () => {
-    expect(item(PACKAGES, '@acme/widgets', 'pages/Home')).toEqual({
-      type: 'discover.item',
-      data: {
-        package: '@acme/widgets',
-        version: '1.2.3',
-        kind: 'template',
-        name: 'pages/Home',
-        installed: true,
-      },
-    });
-  });
-
-  it('finds an item a source lists, with the command that adds its package', () => {
-    expect(
-      item(PACKAGES, '@acme/charts', 'pages/report', {catalog: CATALOG, add}),
-    ).toEqual({
-      type: 'discover.item',
-      data: {
-        package: '@acme/charts',
-        version: '2.0.0',
-        kind: 'template',
-        name: 'pages/Report',
-        title: 'Report page',
-        installed: false,
-        install: 'pnpm add @acme/charts',
-        source: 'Acme',
-      },
-    });
-  });
-
-  it('returns null when neither the project nor a source has it', () => {
-    expect(item(PACKAGES, '@acme/widgets', 'Nope')).toBeNull();
-    expect(item(PACKAGES, '@acme/charts', 'Nope', {catalog: CATALOG})).toBeNull();
-  });
-});

package/api/integration/pack-check.lifecycle-output.test.mjs

@@ -1,107 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-import {afterEach, beforeEach, describe, expect, it} from 'vitest';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import {integrationPackCheck} from './pack-check.mjs';
-
-let tmpDir;
-
-beforeEach(() => {
-  tmpDir = fs.mkdtempSync(path.join(process.cwd(), '.astryx-pack-check-'));
-});
-
-afterEach(() => {
-  fs.rmSync(tmpDir, {recursive: true, force: true});
-});
-
-/** @param {Record<string, string>} scripts */
-function writeThemePackage(scripts) {
-  fs.writeFileSync(
-    path.join(tmpDir, 'package.json'),
-    `${JSON.stringify(
-      {
-        name: '@acme/widgets',
-        version: '1.0.0',
-        files: ['astryx.integration.mjs', 'themes'],
-        peerDependencies: {'@astryxdesign/cli': '>=0.7.0'},
-        peerDependenciesMeta: {'@astryxdesign/cli': {optional: true}},
-        scripts,
-      },
-      null,
-      2,
-    )}\n`,
-  );
-  fs.writeFileSync(
-    path.join(tmpDir, 'astryx.integration.mjs'),
-    "export default {themes: './themes'};\n",
-  );
-  const root = path.join(tmpDir, 'themes');
-  fs.mkdirSync(path.join(root, 'ocean'), {recursive: true});
-  fs.writeFileSync(
-    path.join(root, 'ocean', 'oceanTheme.ts'),
-    "import {defineTheme} from '@astryxdesign/core/theme';\n\nexport const oceanTheme = defineTheme({name: 'ocean'});\n",
-  );
-  fs.writeFileSync(
-    path.join(root, 'ocean', 'oceanTheme.doc.mjs'),
-    `/** @type {import('@astryxdesign/cli/authoring').ThemeDoc} */
-export default {type: 'theme', name: 'ocean', displayName: 'Ocean', description: 'Ocean theme.', maintained: true};
-`,
-  );
-}
-
-describe('integrationPackCheck with lifecycle script output', () => {
-  it('checks the tarball when lifecycle scripts print to stdout', async () => {
-    writeThemePackage({
-      prepack: 'node -e "console.log(\'building the package\')"',
-      prepare: 'node -e "console.log(\'preparing\')"',
-      postpack: 'node -e "console.log(\'packed\')"',
-    });
-
-    const result = await integrationPackCheck({cwd: tmpDir});
-
-    expect(result.data.issues).toEqual([]);
-    expect(result.data.packable).toBe(true);
-    expect(result.data.tarball?.filename).toBe('acme-widgets-1.0.0.tgz');
-    expect(result.data.contributions.packed).toEqual(
-      result.data.contributions.local,
-    );
-  });
-
-  it('still runs a chatty lifecycle script and compares what it packed', async () => {
-    const renameTheme = [
-      "console.log('renaming ocean to storm')",
-      "const fs=require('fs')",
-      "fs.renameSync('themes/ocean','themes/storm')",
-      "const p='themes/storm/oceanTheme.doc.mjs'",
-      "let x=fs.readFileSync(p,'utf8')",
-      "x=x.replace(/name: 'ocean'/, 'name: '+String.fromCharCode(39)+'storm'+String.fromCharCode(39))",
-      'fs.writeFileSync(p,x)',
-    ].join(';');
-    writeThemePackage({prepack: `node -e "${renameTheme}"`});
-
-    const result = await integrationPackCheck({cwd: tmpDir});
-    const codes = result.data.issues.map(issue => issue.code);
-
-    expect(codes).not.toContain('pack_failed');
-    expect(codes).toContain('identity_not_packed');
-    expect(codes).toContain('packed_identity_unexpected');
-    expect(result.data.packable).toBe(false);
-  });
-
-  it('keeps a failing lifecycle script output in the pack_failed issue', async () => {
-    writeThemePackage({
-      prepack:
-        'node -e "console.error(\'prepack exploded\'); process.exit(3)"',
-    });
-
-    const result = await integrationPackCheck({cwd: tmpDir});
-    const failure = result.data.issues.find(
-      issue => issue.code === 'pack_failed',
-    );
-
-    expect(result.data.packable).toBe(false);
-    expect(failure?.message).toContain('npm pack failed (exit 3)');
-    expect(failure?.message).toContain('prepack exploded');
-  });
-});