@astryxdesign/cli 0.1.6-canary.fec872b → 0.1.6

package/src/codemods/transforms/v0.1.7/migrate-table-tableprops-to-direct-props.mjs

@@ -1,188 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file Codemod: Migrate Table tableProps to direct root props
- * @see https://github.com/facebook/astryx/issues/3679
- *
- * `tableProps` (typed HTMLAttributes<HTMLTableElement>, nesting HTML
- * attributes one level deep) is deprecated. As of v0.1.7, <Table> honors
- * className/style/xstyle directly and spreads all other BaseProps
- * (id, aria-*, data-*, event handlers, ...) onto the root <table>, with
- * direct props taking precedence over tableProps.
- *
- * This codemod lifts object-literal `tableProps` keys into sibling JSX
- * props:
- *
- * - tableProps={{className: 'x', style: s}} → className="x" style={s}
- * - String-literal keys ('aria-label', 'data-testid') become hyphenated
- *   JSX attributes.
- * - Keys that collide with an existing sibling attribute (or fail the
- *   attribute-name guard) are kept inside a shrunken tableProps with a
- *   trailing TODO comment for manual migration.
- * - Dynamic values (tableProps={props}, tableProps={fn()}, objects with
- *   spreads/computed keys/methods) are left untouched with a TODO comment.
- *
- * Only elements whose name resolves to a `Table` import (alias-aware)
- * from an Astryx core source are rewritten. No import changes are needed.
- */
-
-export const meta = {
-  title: 'Migrate Table tableProps to direct root props',
-  description:
-    'Lifts object-literal `tableProps` keys on <Table> into sibling JSX props ' +
-    '(className, style, id, aria-*, data-*, event handlers). Dynamic or ' +
-    'colliding entries are kept and annotated with a TODO comment.',
-  pr: '#3679',
-};
-
-/** Import sources that provide the Astryx Table component. */
-const TABLE_IMPORT_SOURCES = new Set([
-  '@astryxdesign/core',
-  '@astryxdesign/core/Table',
-  '@xds/core',
-  '@xds/core/Table',
-]);
-
-/** Keys must be valid JSX attribute names to be lifted. */
-const LIFTABLE_KEY_RE = /^[a-zA-Z_][a-zA-Z0-9_-]*$/;
-
-const TODO_COMMENT =
-  ' TODO(astryx): tableProps is deprecated — merge these into direct props manually ';
-
-/**
- * Extract the static key name from an object property, or null when the
- * property is not a simple liftable entry (spread, computed key, method,
- * getter/setter, non-string literal key).
- */
-function getPropertyKeyName(prop) {
-  if (prop.type !== 'ObjectProperty' && prop.type !== 'Property') return null;
-  // espree-style Property nodes: skip methods and accessors
-  if (prop.method || (prop.kind != null && prop.kind !== 'init')) return null;
-  if (prop.computed) return null;
-  const key = prop.key;
-  if (key.type === 'Identifier') return key.name;
-  if (
-    (key.type === 'StringLiteral' || key.type === 'Literal') &&
-    typeof key.value === 'string'
-  ) {
-    return key.value;
-  }
-  return null;
-}
-
-export default function transformer(file, api) {
-  const j = api.jscodeshift;
-  const root = j(file.source);
-  let hasChanges = false;
-
-  // --- 1. Track local names for the Table import (alias-aware) ---
-  const tableLocals = new Set();
-  root.find(j.ImportDeclaration).forEach((path) => {
-    if (!TABLE_IMPORT_SOURCES.has(path.node.source.value)) return;
-    for (const spec of path.node.specifiers ?? []) {
-      if (spec.type === 'ImportSpecifier' && spec.imported.name === 'Table') {
-        tableLocals.add(spec.local.name);
-      }
-    }
-  });
-
-  if (tableLocals.size === 0) return undefined;
-
-  function attachTodo(attr) {
-    if (!attr.comments) attr.comments = [];
-    if (attr.comments.some((c) => c.value === TODO_COMMENT)) return;
-    attr.comments.push(j.commentBlock(TODO_COMMENT, false, true));
-    hasChanges = true;
-  }
-
-  function buildAttributeValue(valueNode) {
-    if (
-      valueNode.type === 'StringLiteral' ||
-      (valueNode.type === 'Literal' && typeof valueNode.value === 'string')
-    ) {
-      return j.stringLiteral(valueNode.value);
-    }
-    return j.jsxExpressionContainer(valueNode);
-  }
-
-  // --- 2. Rewrite tableProps on tracked <Table> elements ---
-  root.find(j.JSXOpeningElement).forEach((path) => {
-    const name = path.node.name;
-    const componentName = name.type === 'JSXIdentifier' ? name.name : null;
-    if (!componentName || !tableLocals.has(componentName)) return;
-
-    const attrs = path.node.attributes;
-    const tablePropsAttr = attrs.find(
-      (a) => a.type === 'JSXAttribute' && a.name?.name === 'tableProps',
-    );
-    if (!tablePropsAttr) return;
-
-    const value = tablePropsAttr.value;
-    const isObjectLiteral =
-      value?.type === 'JSXExpressionContainer' &&
-      value.expression.type === 'ObjectExpression';
-
-    // Dynamic case: tableProps={identifier}, tableProps={fn()}, ... —
-    // leave the attribute untouched and warn via a trailing comment
-    // (api.report is a stub; comments are the only warning channel).
-    if (!isObjectLiteral) {
-      attachTodo(tablePropsAttr);
-      return;
-    }
-
-    const obj = value.expression;
-
-    // Objects containing spreads, computed keys, or methods are treated
-    // as dynamic: no partial lift, just the TODO comment.
-    const allSimple = obj.properties.every(
-      (prop) => getPropertyKeyName(prop) !== null,
-    );
-    if (!allSimple) {
-      attachTodo(tablePropsAttr);
-      return;
-    }
-
-    const lifted = [];
-    const kept = [];
-    for (const prop of obj.properties) {
-      const keyName = getPropertyKeyName(prop);
-      const collidesWithSibling = attrs.some(
-        (a) => a.type === 'JSXAttribute' && a.name?.name === keyName,
-      );
-      const collidesWithLifted = lifted.some(
-        (a) => a.name.name === keyName,
-      );
-      if (
-        !LIFTABLE_KEY_RE.test(keyName) ||
-        collidesWithSibling ||
-        collidesWithLifted
-      ) {
-        kept.push(prop);
-        continue;
-      }
-      lifted.push(
-        j.jsxAttribute(
-          j.jsxIdentifier(keyName),
-          buildAttributeValue(prop.value),
-        ),
-      );
-    }
-
-    const tablePropsIdx = attrs.indexOf(tablePropsAttr);
-    if (kept.length === 0) {
-      // All keys lifted — replace tableProps with the sibling attributes.
-      attrs.splice(tablePropsIdx, 1, ...lifted);
-      hasChanges = true;
-    } else {
-      // Some keys collide or fail the name guard — keep only those in a
-      // shrunken tableProps and flag it for manual migration.
-      attrs.splice(tablePropsIdx, 0, ...lifted);
-      obj.properties = kept;
-      attachTodo(tablePropsAttr);
-      if (lifted.length > 0) hasChanges = true;
-    }
-  });
-
-  if (!hasChanges) return undefined;
-  return root.toSource({quote: 'single'});
-}

package/src/doc.mjs

@@ -1,27 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file Doc-authoring API (public `@astryxdesign/cli/doc`).
- *
- * The `createComponentDoc`/`createFunctionDoc`/`createDoc` authoring helpers now
- * live in `@astryxdesign/core/authoring` and are re-exported here so existing
- * `@astryxdesign/cli/doc` imports keep working. The Zod load-boundary schemas
- * live in `./schemas/doc-schema.mjs` (core-free) and are re-exported here for
- * back-compat; internal hot-path code imports them from the schema module
- * directly so it never depends on core's built `dist/`.
- */
-
-export {
-  createComponentDoc,
-  createFunctionDoc,
-  createDoc,
-} from '@astryxdesign/core/authoring';
-
-export {
-  ComponentDocKindSchema,
-  FunctionDocKindSchema,
-  GenericDocKindSchema,
-  StampedDocSchema,
-  LegacyDocSchema,
-  ComponentDocSchema,
-} from './schemas/doc-schema.mjs';

package/src/doc.test.mjs

@@ -1,383 +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 {
-  createComponentDoc,
-  createFunctionDoc,
-  createDoc,
-  ComponentDocSchema,
-  ComponentDocKindSchema,
-  FunctionDocKindSchema,
-  GenericDocKindSchema,
-} from './doc.mjs';
-import {loadComponentDoc} from './lib/component-loader.mjs';
-
-// The factories are stamp-only (like createConfig / createBlockTemplate): they
-// inject a `type` discriminant and are otherwise identity, performing NO
-// runtime validation. Validation happens at the LOAD boundary
-// (loadComponentDoc runs the loaded value through ComponentDocSchema), so the
-// rejection cases assert the schema rejects rather than the factory throwing.
-
-const goodComponent = {
-  name: 'Widget',
-  displayName: 'Widget',
-  description: 'A small widget.',
-  props: [
-    {name: 'label', type: 'string', description: 'Visible label.', required: true},
-    {name: 'size', type: "'sm' | 'md'", description: 'Control size.', default: "'md'"},
-  ],
-};
-
-const goodFunction = {
-  name: 'useThing',
-  displayName: 'useThing',
-  description: 'A thing hook.',
-  params: [{name: 'input', type: 'string', description: 'The input.', required: true}],
-  returns: [{name: 'value', type: 'string', description: 'The result.'}],
-};
-
-const goodGeneric = {
-  name: 'Theming',
-  displayName: 'Theming',
-  description: 'How theming works.',
-};
-
-describe('doc factories (stamp-only)', () => {
-  it('createComponentDoc stamps type: component and is otherwise identity', () => {
-    const doc = createComponentDoc(goodComponent);
-    expect(doc.type).toBe('component');
-    const {type, ...rest} = doc;
-    expect(rest).toEqual(goodComponent);
-  });
-
-  it('createFunctionDoc stamps type: function and is otherwise identity', () => {
-    const doc = createFunctionDoc(goodFunction);
-    expect(doc.type).toBe('function');
-    const {type, ...rest} = doc;
-    expect(rest).toEqual(goodFunction);
-  });
-
-  it('createDoc stamps type: generic and is otherwise identity', () => {
-    const doc = createDoc(goodGeneric);
-    expect(doc.type).toBe('generic');
-    const {type, ...rest} = doc;
-    expect(rest).toEqual(goodGeneric);
-  });
-
-  it('does NOT validate — stamps invalid shapes unchanged', () => {
-    const bogus = {group: 'Buttons'}; // no name
-    expect(createComponentDoc(bogus)).toEqual({...bogus, type: 'component'});
-  });
-});
-
-describe('per-kind schemas (new stamped format)', () => {
-  it('ComponentDocKindSchema accepts a valid component doc', () => {
-    expect(() =>
-      ComponentDocKindSchema.parse(createComponentDoc(goodComponent)),
-    ).not.toThrow();
-  });
-
-  it('ComponentDocKindSchema rejects a missing name with a readable message', () => {
-    expect(() =>
-      ComponentDocKindSchema.parse({type: 'component', name: '', props: []}),
-    ).toThrow(/name is required/);
-  });
-
-  it('ComponentDocKindSchema rejects a prop missing its type with a readable message', () => {
-    expect(() =>
-      ComponentDocKindSchema.parse({
-        type: 'component',
-        name: 'Widget',
-        props: [{name: 'label', description: 'no type'}],
-      }),
-    ).toThrow(/type/);
-  });
-
-  it('ComponentDocKindSchema surfaces the custom message for an empty prop type', () => {
-    expect(() =>
-      ComponentDocKindSchema.parse({
-        type: 'component',
-        name: 'Widget',
-        props: [{name: 'label', type: '', description: 'empty type'}],
-      }),
-    ).toThrow(/prop type is required/);
-  });
-
-  it('FunctionDocKindSchema accepts a valid function doc', () => {
-    expect(() =>
-      FunctionDocKindSchema.parse(createFunctionDoc(goodFunction)),
-    ).not.toThrow();
-  });
-
-  it('FunctionDocKindSchema rejects a function doc missing returns', () => {
-    expect(() =>
-      FunctionDocKindSchema.parse({
-        type: 'function',
-        name: 'useThing',
-        params: [],
-      }),
-    ).toThrow();
-  });
-
-  it('GenericDocKindSchema accepts a valid generic doc', () => {
-    expect(() =>
-      GenericDocKindSchema.parse(createDoc(goodGeneric)),
-    ).not.toThrow();
-  });
-
-  it('keeps nested rich blobs loose (usage/theming/playground passthrough)', () => {
-    const doc = createComponentDoc({
-      ...goodComponent,
-      usage: {description: 'Use it.', anatomy: [{name: 'root'}]},
-      theming: {targets: [{className: 'astryx-widget'}]},
-      playground: {defaults: {label: 'Hi'}},
-      examples: [{title: 'Basic', code: '<Widget />'}],
-    });
-    expect(() => ComponentDocKindSchema.parse(doc)).not.toThrow();
-  });
-
-  it('accepts parent + relatedDocs on the shared base', () => {
-    const doc = createComponentDoc({
-      ...goodComponent,
-      parent: 'WidgetGroup',
-      relatedDocs: ['Gauge', 'useThing'],
-      group: 'Widgets',
-    });
-    const parsed = ComponentDocKindSchema.parse(doc);
-    expect(parsed.parent).toBe('WidgetGroup');
-    expect(parsed.relatedDocs).toEqual(['Gauge', 'useThing']);
-  });
-});
-
-describe('ComponentDocSchema (load-boundary, both formats)', () => {
-  it('accepts a stamped component doc via the per-kind schema', () => {
-    expect(() =>
-      ComponentDocSchema.parse(createComponentDoc(goodComponent)),
-    ).not.toThrow();
-  });
-
-  it('accepts a stamped function doc', () => {
-    expect(() =>
-      ComponentDocSchema.parse(createFunctionDoc(goodFunction)),
-    ).not.toThrow();
-  });
-
-  it('accepts a stamped generic doc', () => {
-    expect(() =>
-      ComponentDocSchema.parse(createDoc(goodGeneric)),
-    ).not.toThrow();
-  });
-
-  it('accepts the OLD loose single-component shape (no type)', () => {
-    expect(() => ComponentDocSchema.parse(goodComponent)).not.toThrow();
-  });
-
-  it('accepts the OLD loose multi-component shape (components[])', () => {
-    const multi = {
-      name: 'Table',
-      displayName: 'Table',
-      components: [{name: 'TableRow', displayName: 'Table Row', description: 'A row.'}],
-    };
-    expect(() => ComponentDocSchema.parse(multi)).not.toThrow();
-  });
-
-  it('accepts the OLD loose sub-component shape (subComponentOf)', () => {
-    const sub = {
-      name: 'GaugeItem',
-      subComponentOf: 'Gauge',
-      displayName: 'Gauge Item',
-      description: 'A gauge item.',
-      props: [{name: 'item', type: 'Item', description: 'The item.'}],
-    };
-    expect(() => ComponentDocSchema.parse(sub)).not.toThrow();
-  });
-
-  it('accepts the OLD loose standalone-hook shape (params + returns, no type)', () => {
-    const hook = {
-      name: 'useThing',
-      displayName: 'useThing',
-      params: [{name: 'q', type: 'string', description: 'query'}],
-      returns: [{name: 'value', type: 'boolean', description: 'match'}],
-    };
-    expect(() => ComponentDocSchema.parse(hook)).not.toThrow();
-  });
-
-  it('accepts BOTH parent and legacy subComponentOf', () => {
-    const withParent = {name: 'A', parent: 'B', props: []};
-    const withSubComponentOf = {
-      name: 'A',
-      subComponentOf: 'B',
-      description: 'sub',
-      props: [],
-    };
-    expect(() => ComponentDocSchema.parse(withParent)).not.toThrow();
-    expect(() => ComponentDocSchema.parse(withSubComponentOf)).not.toThrow();
-  });
-
-  it('accepts BOTH relatedDocs and legacy relatedComponents/relatedHooks', () => {
-    const legacy = {
-      name: 'useThing',
-      displayName: 'useThing',
-      params: [],
-      returns: [],
-      relatedComponents: ['Gauge'],
-      relatedHooks: ['useOther'],
-    };
-    const modern = {...goodComponent, relatedDocs: ['Gauge', 'useThing']};
-    expect(() => ComponentDocSchema.parse(legacy)).not.toThrow();
-    expect(() =>
-      ComponentDocSchema.parse(createComponentDoc(modern)),
-    ).not.toThrow();
-  });
-
-  it('passes through loose extras (usage, playground, theming, importPath, showcase)', () => {
-    const loose = {
-      ...goodComponent,
-      usage: {description: 'Use it wisely.'},
-      playground: {defaults: {label: 'Hi'}},
-      theming: {targets: [{className: 'astryx-widget'}]},
-      keywords: ['widget', 'thing'],
-      category: 'Content',
-      isHiddenFromOverview: true,
-      importPath: '@astryxdesign/core/Widget',
-      showcase: 'WidgetHero',
-    };
-    const parsed = ComponentDocSchema.parse(loose);
-    expect(parsed.importPath).toBe('@astryxdesign/core/Widget');
-    expect(parsed.showcase).toBe('WidgetHero');
-  });
-
-  it('rejects a doc with no name', () => {
-    expect(() => ComponentDocSchema.parse({props: []})).toThrow();
-  });
-
-  it('rejects an empty name with a readable message', () => {
-    expect(() => ComponentDocSchema.parse({name: '', props: []})).toThrow(
-      /name is required/,
-    );
-  });
-});
-
-describe('loadComponentDoc (load boundary)', () => {
-  let tmpDir;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(process.cwd(), '.astryx-doc-test-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, {recursive: true, force: true});
-  });
-
-  const docModule = () => JSON.stringify(path.resolve(import.meta.dirname, 'doc.mjs'));
-
-  it('loads a .doc.ts fixture via jiti (createComponentDoc default export)', async () => {
-    const file = path.join(tmpDir, 'Widget.doc.ts');
-    fs.writeFileSync(
-      file,
-      [
-        `import {createComponentDoc} from ${docModule()};`,
-        'export default createComponentDoc({',
-        "  name: 'Widget',",
-        "  displayName: 'Widget',",
-        "  description: 'A small widget.',",
-        '  props: [',
-        "    {name: 'label', type: 'string', description: 'Visible label.', required: true},",
-        '  ],',
-        '});',
-      ].join('\n'),
-    );
-    const docs = await loadComponentDoc(file);
-    expect(docs.type).toBe('component');
-    expect(docs.name).toBe('Widget');
-    expect(docs.props).toHaveLength(1);
-  });
-
-  it('loads a .doc.ts fixture via jiti (createFunctionDoc default export)', async () => {
-    const file = path.join(tmpDir, 'useThing.doc.ts');
-    fs.writeFileSync(
-      file,
-      [
-        `import {createFunctionDoc} from ${docModule()};`,
-        'export default createFunctionDoc({',
-        "  name: 'useThing',",
-        "  displayName: 'useThing',",
-        "  params: [{name: 'input', type: 'string', description: 'The input.'}],",
-        "  returns: [{name: 'value', type: 'string', description: 'The result.'}],",
-        '});',
-      ].join('\n'),
-    );
-    const docs = await loadComponentDoc(file);
-    expect(docs.type).toBe('function');
-    expect(docs.params).toHaveLength(1);
-    expect(docs.returns).toHaveLength(1);
-  });
-
-  it('loads a .doc.ts fixture via jiti (createDoc generic default export)', async () => {
-    const file = path.join(tmpDir, 'Theming.doc.ts');
-    fs.writeFileSync(
-      file,
-      [
-        `import {createDoc} from ${docModule()};`,
-        'export default createDoc({',
-        "  name: 'Theming',",
-        "  displayName: 'Theming',",
-        "  description: 'How theming works.',",
-        '});',
-      ].join('\n'),
-    );
-    const docs = await loadComponentDoc(file);
-    expect(docs.type).toBe('generic');
-    expect(docs.name).toBe('Theming');
-  });
-
-  it('REGRESSION: loads the OLD loose `export const docs = {}` format', async () => {
-    const file = path.join(tmpDir, 'Legacy.doc.mjs');
-    fs.writeFileSync(
-      file,
-      [
-        'export const docs = {',
-        "  name: 'Legacy',",
-        "  displayName: 'Legacy',",
-        "  description: 'A loose named-export doc.',",
-        "  relatedComponents: ['Gauge'],",
-        "  relatedHooks: ['useThing'],",
-        "  importPath: '@astryxdesign/core/Legacy',",
-        "  props: [{name: 'value', type: 'string', description: 'A value.'}],",
-        '};',
-      ].join('\n'),
-    );
-    const docs = await loadComponentDoc(file);
-    expect(docs.name).toBe('Legacy');
-    expect(docs.props[0].name).toBe('value');
-    expect(docs.relatedComponents).toEqual(['Gauge']);
-    expect(docs.importPath).toBe('@astryxdesign/core/Legacy');
-  });
-
-  it('REGRESSION: loads the OLD loose standalone-hook `docs` format', async () => {
-    const file = path.join(tmpDir, 'useLegacy.doc.mjs');
-    fs.writeFileSync(
-      file,
-      [
-        'export const docs = {',
-        "  name: 'useLegacy',",
-        "  displayName: 'useLegacy',",
-        "  params: [{name: 'q', type: 'string', description: 'query'}],",
-        "  returns: [{name: 'value', type: 'boolean', description: 'match'}],",
-        "  relatedHooks: ['useThing'],",
-        '};',
-      ].join('\n'),
-    );
-    const docs = await loadComponentDoc(file);
-    expect(docs.name).toBe('useLegacy');
-    expect(docs.returns[0].name).toBe('value');
-  });
-
-  it('throws a readable error for an invalid doc', async () => {
-    const file = path.join(tmpDir, 'Bad.doc.mjs');
-    fs.writeFileSync(file, 'export default {group: "Buttons"};\n');
-    await expect(loadComponentDoc(file)).rejects.toThrow(/is invalid|name/);
-  });
-});

package/src/lib/component-discovery.importpath.test.mjs

@@ -1,59 +0,0 @@
-// Copyright (c) Meta Platforms, Inc. and affiliates.
-
-/**
- * @file Verifies that `.ts`-authored sources (hooks and other functions) are
- * found by `findComponentSource`, so `resolveImportPath` derives a
- * tree-shakeable subpath instead of falling back to the bare package root.
- *
- * Runs against the real packages/core source, not mocks.
- */
-
-import {describe, it, expect} from 'vitest';
-import {
-  findComponentSource,
-  resolveImportPath,
-} from './component-discovery.mjs';
-import {findCoreDir} from '../utils/paths.mjs';
-
-describe('findComponentSource resolves .ts-authored sources', () => {
-  const coreDir = findCoreDir();
-
-  it('finds a hook authored as a .ts file (not just .tsx)', () => {
-    const src = findComponentSource(coreDir, 'useMediaQuery');
-    expect(src).toBeTruthy();
-    expect(src.endsWith('useMediaQuery.ts')).toBe(true);
-  });
-
-  it('still finds a component authored as .tsx', () => {
-    const src = findComponentSource(coreDir, 'Button');
-    expect(src).toBeTruthy();
-    expect(src.endsWith('.tsx')).toBe(true);
-  });
-});
-
-describe('resolveImportPath reproduces authored hook importPaths', () => {
-  const coreDir = findCoreDir();
-
-  // Representative sample of core hooks whose sources are `.ts` files. Before
-  // the `.ts` fix these fell back to bare `@astryxdesign/core`; the derived
-  // subpath must now match the value each hook's doc currently authors.
-  const cases = [
-    ['useMediaQuery', '@astryxdesign/core/hooks'],
-    ['useResizable', '@astryxdesign/core/Resizable'],
-    ['useTheme', '@astryxdesign/core/theme'],
-    ['useFocusTrap', '@astryxdesign/core/hooks'],
-    ['useOverflow', '@astryxdesign/core/hooks'],
-  ];
-
-  for (const [name, expected] of cases) {
-    it(`${name} derives ${expected}`, () => {
-      expect(resolveImportPath(coreDir, name)).toBe(expected);
-    });
-  }
-
-  it('never falls back to the bare package root for a .ts hook', () => {
-    for (const [name] of cases) {
-      expect(resolveImportPath(coreDir, name)).not.toBe('@astryxdesign/core');
-    }
-  });
-});