@the-portland-company/shell 0.89.0 → 0.91.0

package/eslint/index.cjs

@@ -1,172 +0,0 @@
-'use strict'
-// Shell primitives guard. Spec: Components — shared primitives are mandatory.
-const SHELL_PKG = '@the-portland-company/shell'
-const LOCAL_NAMES = new Set(['Button', 'Card', 'Input', 'Select', 'Textarea', 'Checkbox', 'FileInput', 'PageHeader', 'FormColumn'])
-const RAW_TO_PRIMITIVE = { button: 'Button', input: 'Input', select: 'Select', textarea: 'Textarea' }
-const GLOBAL_CLASS_RE = /\b(btn|input)(-[a-z]+)?\b/
-const EXEMPT_RE = /shell-primitive-exempt:\s*\S+/
-
-const isShellSource = (s) => typeof s === 'string' && (s === SHELL_PKG || s.startsWith(SHELL_PKG + '/'))
-
-/** True when an exempt comment (with a reason) is on the node's line or the line above. */
-function isExempt(context, node) {
-  const sc = context.sourceCode || context.getSourceCode()
-  const start = node.loc.start.line
-  return sc.getAllComments().some(
-    (c) => EXEMPT_RE.test(c.value) && c.loc.end.line >= start - 1 && c.loc.end.line <= start,
-  )
-}
-
-const noLocalPrimitives = {
-  meta: {
-    type: 'problem',
-    schema: [],
-    messages: {
-      local: 'Do not declare or export a local "{{name}}". Import it from @the-portland-company/shell (shared primitives are mandatory); add variants to the shell instead.',
-    },
-  },
-  create(context) {
-    const report = (node, name) => {
-      if (LOCAL_NAMES.has(name) && !isExempt(context, node)) {
-        context.report({ node, messageId: 'local', data: { name } })
-      }
-    }
-    return {
-      FunctionDeclaration: (n) => n.id && report(n.id, n.id.name),
-      ClassDeclaration: (n) => n.id && report(n.id, n.id.name),
-      VariableDeclarator: (n) => n.id.type === 'Identifier' && report(n.id, n.id.name),
-      ExportSpecifier(n) {
-        const parent = n.parent
-        const exported = n.exported.name || n.exported.value
-        if (parent.source) {
-          if (!isShellSource(parent.source.value)) report(n, exported)
-        } else if (n.local.name !== exported) {
-          report(n, exported) // `export { Foo as Button }`; same-name locals are caught at declaration
-        }
-      },
-    }
-  },
-}
-
-const noRawControlStyling = {
-  meta: {
-    type: 'problem',
-    schema: [],
-    messages: {
-      raw: '<{{tag}}> with {{prop}} hand-rolls a control. Use <{{primitive}}> from @the-portland-company/shell, or add "// shell-primitive-exempt: <reason>".',
-    },
-  },
-  create(context) {
-    const imported = new Set()
-    return {
-      ImportDeclaration(n) {
-        if (!isShellSource(n.source.value)) return
-        for (const s of n.specifiers) if (s.type === 'ImportSpecifier') imported.add(s.imported.name || s.imported.value)
-      },
-      JSXOpeningElement(n) {
-        if (n.name.type !== 'JSXIdentifier') return
-        const tag = n.name.name
-        let primitive = RAW_TO_PRIMITIVE[tag]
-        if (tag === 'input') {
-          // <input type="checkbox|file"> needs Checkbox / FileInput; importing Input does not excuse it.
-          const typeAttr = n.attributes.find(
-            (a) => a.type === 'JSXAttribute' && a.name.type === 'JSXIdentifier' && a.name.name === 'type',
-          )
-          const v = typeAttr && typeAttr.value
-          const typeValue =
-            v && v.type === 'Literal' ? v.value
-            : v && v.type === 'JSXExpressionContainer' && v.expression.type === 'Literal' ? v.expression.value
-            : null
-          if (typeValue === 'checkbox') primitive = 'Checkbox'
-          else if (typeValue === 'file') primitive = 'FileInput'
-        }
-        if (!primitive) return
-        const attr = n.attributes.find(
-          (a) => a.type === 'JSXAttribute' && a.name.type === 'JSXIdentifier' && (a.name.name === 'className' || a.name.name === 'style'),
-        )
-        if (!attr) return
-        if (imported.has(primitive)) return // wrapping the shell primitive
-        if (isExempt(context, n)) return
-        context.report({ node: attr, messageId: 'raw', data: { tag, prop: attr.name.name, primitive } })
-      },
-    }
-  },
-}
-
-const noGlobalControlClasses = {
-  meta: {
-    type: 'problem',
-    schema: [],
-    messages: {
-      global: 'className "{{value}}" relies on a global btn/input class. Use the shell Button/Input primitives.',
-    },
-  },
-  create(context) {
-    function scan(node, root) {
-      if (!node) return
-      switch (node.type) {
-        case 'Literal':
-          if (typeof node.value === 'string') check(node.value, node, root)
-          break
-        case 'TemplateLiteral':
-          node.quasis.forEach((q) => check(q.value.cooked || '', q, root))
-          node.expressions.forEach((e) => scan(e, root))
-          break
-        case 'JSXExpressionContainer':
-          scan(node.expression, root)
-          break
-        case 'ConditionalExpression':
-          scan(node.consequent, root)
-          scan(node.alternate, root)
-          break
-        case 'LogicalExpression':
-        case 'BinaryExpression':
-          scan(node.left, root)
-          scan(node.right, root)
-          break
-        case 'CallExpression':
-          node.arguments.forEach((a) => scan(a, root))
-          break
-        case 'ArrayExpression':
-          node.elements.forEach((a) => scan(a, root))
-          break
-        case 'ObjectExpression':
-          node.properties.forEach((p) => p.type === 'Property' && scan(p.key, root))
-          break
-      }
-    }
-    function check(text, node, root) {
-      if (GLOBAL_CLASS_RE.test(text) && !isExempt(context, root)) {
-        context.report({ node, messageId: 'global', data: { value: text.trim() } })
-      }
-    }
-    return {
-      JSXAttribute(n) {
-        if (n.name.type === 'JSXIdentifier' && n.name.name === 'className') scan(n.value, n)
-      },
-    }
-  },
-}
-
-const rules = {
-  'no-local-primitives': noLocalPrimitives,
-  'no-raw-control-styling': noRawControlStyling,
-  'no-global-control-classes': noGlobalControlClasses,
-}
-
-const plugin = { meta: { name: SHELL_PKG + '/eslint' }, rules, configs: {} }
-
-// Flat config: `export default [...shell.configs.recommended]`
-plugin.configs.recommended = [
-  {
-    files: ['**/*.{js,jsx,ts,tsx,mjs,cjs}'],
-    plugins: { 'politogy-shell': plugin },
-    rules: {
-      'politogy-shell/no-local-primitives': 'error',
-      'politogy-shell/no-raw-control-styling': 'error',
-      'politogy-shell/no-global-control-classes': 'error',
-    },
-  },
-]
-
-module.exports = plugin

package/eslint/index.d.ts

@@ -1,6 +0,0 @@
-import type { Linter, ESLint } from 'eslint'
-
-declare const plugin: ESLint.Plugin & { configs: { recommended: Linter.Config[] } }
-export default plugin
-export const rules: ESLint.Plugin['rules']
-export const configs: { recommended: Linter.Config[] }

package/eslint/index.mjs

@@ -1,5 +0,0 @@
-import plugin from './index.cjs'
-
-export default plugin
-export const rules = plugin.rules
-export const configs = plugin.configs