@swiftwc/eslint-plugin 1.0.0 → 1.1.1

package/README.md

@@ -1,3 +1,15 @@
 # @swiftwc/eslint-plugin
 
 [README](https://github.com/swiftwc/ui/blob/main/README.md)
+
+## Documentation
+
+Visit [swiftwc.github.io/ui/](https://swiftwc.github.io/ui/) to view the documentation.
+
+## Contributing
+
+Please read the [contributing guide](https://github.com/swiftwc/ui/blob/main/CONTRIBUTING.md).
+
+## License
+
+Licensed under the [MIT license](https://github.com/swiftwc/ui/blob/main/LICENSE.md).

package/generated/emberjs/en.d.ts

@@ -0,0 +1,2 @@
+import { swiftwc } from '../index.js';
+export default swiftwc;

package/generated/emberjs/en.js

@@ -0,0 +1,19 @@
+import { RULES, swiftwc, validate } from '../index.js';
+swiftwc.rules['allowed-tags'].meta.docs.description = 'Restrict allowed HTML tags';
+swiftwc.rules['allowed-tags'].meta.messages.disallowedTag = 'Tag <{{tag}}> is only allowed inside any of: {{allowed}}';
+swiftwc.rules['allowed-tags'].create = (context) => {
+    return {
+        // '*': (node) => {
+        // if('GlimmerElementNode' !== node.type) return
+        GlimmerElementNode(node) {
+            // @ts-expect-error
+            const tag = node.tag;
+            const allowedParents = RULES[tag];
+            if (!allowedParents)
+                return; // 👈 ignore unknown tags completely
+            // @ts-expect-error
+            validate(tag, (item) => item.tag, allowedParents, context, node);
+        },
+    };
+};
+export default swiftwc;

package/generated/html/en.d.ts

@@ -0,0 +1,2 @@
+import { swiftwc } from '../index.js';
+export default swiftwc;

package/generated/html/en.js

@@ -0,0 +1,15 @@
+import { RULES, swiftwc, validate } from '../index.js';
+swiftwc.rules['allowed-tags'].meta.docs.description = 'Restrict allowed HTML tags';
+swiftwc.rules['allowed-tags'].meta.messages.disallowedTag = 'Tag <{{tag}}> is only allowed inside any of: {{allowed}}';
+swiftwc.rules['allowed-tags'].create = (context) => {
+    return {
+        Tag(node) {
+            const tag = node.name;
+            const allowedParents = RULES[tag];
+            if (!allowedParents)
+                return; // 👈 ignore unknown tags completely
+            validate(tag, (item) => item.parent, allowedParents, context, node);
+        },
+    };
+};
+export default swiftwc;

package/generated/index.d.ts

@@ -0,0 +1,32 @@
+import type { RuleContext, RuleListener } from '@typescript-eslint/utils/ts-eslint';
+export type TagNode = {
+    name: string;
+    type: string;
+    parent?: TagNode;
+};
+export declare const RULES: Record<string, string[]>;
+export declare function validate(tag: string, getParentTag: (node: TagNode) => TagNode | undefined, allowedParents: string[], context: RuleContext<string, readonly unknown[]>, node: TagNode): void;
+export declare const swiftwc: {
+    meta: {
+        name: any;
+        version: any;
+        namespace: string;
+    };
+    configs: {};
+    rules: {
+        'allowed-tags': {
+            meta: {
+                type: "problem";
+                docs: {
+                    description: string;
+                    url: string;
+                };
+                schema: never[];
+                messages: {
+                    disallowedTag: string;
+                };
+            };
+            create(context: Readonly<RuleContext<string, readonly unknown[]>>): RuleListener;
+        };
+    };
+};

package/generated/index.js

@@ -0,0 +1,125 @@
+import { readFileSync } from 'fs';
+export const RULES = {
+    'v-keyboard': ['body'],
+    'scroll-view': ['body-view', 'dialog', 'navigation-stack', 'navigation-split-view', 'detail-placeholder'],
+    dialog: ['tab-view', 'template'],
+};
+export function validate(tag, getParentTag, allowedParents, context, node) {
+    let parentTag = getParentTag(node), isValid = false;
+    while (parentTag) {
+        if (parentTag.type === node.type && allowedParents.includes(parentTag.name)) {
+            isValid = true;
+            break;
+        }
+        parentTag = getParentTag(parentTag);
+    }
+    if (isValid)
+        return;
+    context.report({
+        // @ts-expect-error
+        node,
+        messageId: 'disallowedTag',
+        data: {
+            tag,
+            allowed: allowedParents.join(', '),
+        },
+    });
+}
+const { name, version } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+export const swiftwc = {
+    meta: {
+        name,
+        version,
+        namespace: 'swiftwc',
+    },
+    configs: {},
+    rules: {
+        'allowed-tags': {
+            meta: {
+                type: 'problem',
+                docs: {
+                    description: 'Restrict allowed HTML tags',
+                    url: `https://github.com/swiftwc/ui`,
+                },
+                // languages: ['html/html'],
+                schema: [],
+                // schema: [
+                //   {
+                //     type: 'object',
+                //     properties: {
+                //       allowed: {
+                //         type: 'array',
+                //         items: { type: 'string' },
+                //       },
+                //     },
+                //     additionalProperties: false,
+                //   },
+                // ],
+                messages: {
+                    disallowedTag: 'Tag <{{tag}}> is only allowed inside any of: {{allowed}}',
+                },
+            },
+            // create(context) {
+            //   const options = context.options?.[0] || {},
+            //     allowed = new Set(options.allowed || [...DEFAULT_ALLOWED])
+            //   return {
+            //     Tag(node) {
+            //       const tag = node.name
+            //       if (!allowed.has(tag)) {
+            //         context.report({
+            //           node,
+            //           messageId: 'disallowedTag',
+            //           data: {
+            //             tag,
+            //             allowed: [...allowed].join(', '),
+            //           },
+            //         })
+            //       }
+            //     },
+            //   }
+            // },
+            create(context) {
+                return {
+                    Tag(node) {
+                        const tag = node.name;
+                        const allowedParents = RULES[tag];
+                        if (!allowedParents)
+                            return; // 👈 ignore unknown tags completely
+                        validate(tag, (item) => item.parent, allowedParents, context, node);
+                        // let parent = node.parent
+                        // let valid = false
+                        // while (parent) {
+                        //   if (parent.type === 'Tag' && allowedParents.includes(parent.name)) {
+                        //     valid = true
+                        //     break
+                        //   }
+                        //   parent = parent.parent
+                        // }
+                        // if (!valid) {
+                        //   context.report({
+                        //     node,
+                        //     messageId: 'disallowedTag',
+                        //     data: {
+                        //       tag,
+                        //       allowed: allowedParents.join(', '),
+                        //     },
+                        //   })
+                        // }
+                    },
+                };
+            },
+        },
+    },
+};
+Object.assign(swiftwc.configs, {
+    recommended: [
+        {
+            plugins: {
+                swiftwc,
+            },
+            rules: {
+                'swiftwc/allowed-tags': 'error', //['error', { allowed: ['div', 'span', 'my-button', 'my-card'] }],
+            },
+        },
+    ],
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swiftwc/eslint-plugin",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "Rules enforcing best practices while using SwiftWC.",
   "keywords": [
     "eslint",
@@ -22,11 +22,22 @@
   },
   "type": "module",
   "peerDependencies": {
-    "@swiftwc/ui": "^1.0.0",
+    "@swiftwc/ui": "*",
     "eslint": ">=10.0.0"
   },
   "exports": {
-    "./html/en": "./html/en.js",
-    "./emberjs/en": "./emberjs/en.js"
+    "./html/en": "./generated/html/en.js",
+    "./emberjs/en": "./generated/emberjs/en.js"
+  },
+  "scripts": {
+    "prebuild": "rm -rf generated",
+    "build": "npm run build:ts",
+    "build:ts:watch": "npm run prebuild && tsc --watch",
+    "build:ts": "tsc",
+    "format:check": "prettier . --check",
+    "format:write": "prettier . --write"
+  },
+  "devDependencies": {
+    "@typescript-eslint/utils": "^8.59.2"
   }
 }

package/src/emberjs/en.ts

@@ -0,0 +1,24 @@
+import type { RuleContext, RuleListener } from '@typescript-eslint/utils/ts-eslint'
+import { RULES, swiftwc, validate, type TagNode } from '../index.js'
+
+swiftwc.rules['allowed-tags'].meta.docs.description = 'Restrict allowed HTML tags'
+
+swiftwc.rules['allowed-tags'].meta.messages.disallowedTag = 'Tag <{{tag}}> is only allowed inside any of: {{allowed}}'
+
+swiftwc.rules['allowed-tags'].create = (context: Readonly<RuleContext<string, readonly unknown[]>>): RuleListener => {
+  return {
+    // '*': (node) => {
+    // if('GlimmerElementNode' !== node.type) return
+    GlimmerElementNode(node: TagNode) {
+      // @ts-expect-error
+      const tag = node.tag
+
+      const allowedParents = RULES[tag]
+      if (!allowedParents) return // 👈 ignore unknown tags completely
+
+      validate(tag, (item) => item.parent, allowedParents, context, node)
+    },
+  }
+}
+
+export default swiftwc

package/{html/en.js → src/html/en.ts}

@@ -1,12 +1,13 @@
-import { RULES, swiftwc, validate } from '../src/index.js'
+import type { RuleContext, RuleListener } from '@typescript-eslint/utils/ts-eslint'
+import { RULES, swiftwc, validate, type TagNode } from '../index.js'
 
 swiftwc.rules['allowed-tags'].meta.docs.description = 'Restrict allowed HTML tags'
 
 swiftwc.rules['allowed-tags'].meta.messages.disallowedTag = 'Tag <{{tag}}> is only allowed inside any of: {{allowed}}'
 
-swiftwc.rules['allowed-tags'].create = (context) => {
+swiftwc.rules['allowed-tags'].create = (context: Readonly<RuleContext<string, readonly unknown[]>>): RuleListener => {
   return {
-    Tag(node) {
+    Tag(node: TagNode) {
       const tag = node.name
 
       const allowedParents = RULES[tag]

package/src/{index.js → index.ts}

@@ -1,6 +1,13 @@
+import type { Linter, RuleContext, RuleListener } from '@typescript-eslint/utils/ts-eslint'
 import { readFileSync } from 'fs'
 
-export const RULES = {
+export type TagNode = {
+  name: string
+  type: string
+  parent?: TagNode
+}
+
+export const RULES: Record<string, string[]> = {
   'v-keyboard': ['body'],
 
   'scroll-view': ['body-view', 'dialog', 'navigation-stack', 'navigation-split-view', 'detail-placeholder'],
@@ -8,25 +15,29 @@ export const RULES = {
   dialog: ['tab-view', 'template'],
 }
 
-export function validate(tag, getParentTag, allowedParents, context, node) {
-  // let parent = getParentTag(node)
-  // let isValid = false
-
-  // while (parent) {
-  //   if (parent.type === 'Tag' && allowedParents.includes(parent.name)) {
-  //     isValid = true
-  //     break
-  //   }
-  //   parent = getParentTag(parent)
-  // }
-
-  const parentTag = getParentTag(node)
-
-  const isValid = allowedParents.includes(parentTag.name)
+export function validate(
+  tag: string,
+  getParentTag: (node: TagNode) => TagNode | undefined,
+  allowedParents: string[],
+  context: RuleContext<string, readonly unknown[]>,
+  node: TagNode
+) {
+  let parentTag = getParentTag(node),
+    isValid = false
+
+  while (parentTag) {
+    if (parentTag.type === node.type && allowedParents.includes(parentTag.name)) {
+      isValid = true
+      break
+    }
+
+    parentTag = getParentTag(parentTag)
+  }
 
   if (isValid) return
 
   context.report({
+    // @ts-expect-error
     node,
     messageId: 'disallowedTag',
     data: {
@@ -53,7 +64,7 @@ export const swiftwc = {
           description: 'Restrict allowed HTML tags',
           url: `https://github.com/swiftwc/ui`,
         },
-        languages: ['html/html'],
+        // languages: ['html/html'],
         schema: [],
         // schema: [
         //   {
@@ -93,9 +104,9 @@ export const swiftwc = {
       //   }
       // },
 
-      create(context) {
+      create(context: Readonly<RuleContext<string, readonly unknown[]>>): RuleListener {
         return {
-          Tag(node) {
+          Tag(node: TagNode) {
             const tag = node.name
 
             const allowedParents = RULES[tag]
@@ -129,7 +140,7 @@ export const swiftwc = {
       },
     },
   },
-}
+} satisfies Linter.Plugin
 
 Object.assign(swiftwc.configs, {
   recommended: [

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "generated",
+    "rootDir": "src",
+    "skipLibCheck": true,
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "resolveJsonModule": true
+  },
+  "include": ["src"],
+  "exclude": ["**/*.test.ts"]
+}

package/emberjs/en.js

@@ -1,20 +0,0 @@
-import { RULES, swiftwc, validate } from '../src/index.js'
-
-swiftwc.rules['allowed-tags'].meta.docs.description = 'Restrict allowed HTML tags'
-
-swiftwc.rules['allowed-tags'].meta.messages.disallowedTag = 'Tag <{{tag}}> is only allowed inside any of: {{allowed}}'
-
-swiftwc.rules['allowed-tags'].create = (context) => {
-  return {
-    ElementNode(node) {
-      const tag = node.tag
-
-      const allowedParents = RULES[tag]
-      if (!allowedParents) return // 👈 ignore unknown tags completely
-
-      validate(tag, (item) => item.tag, allowedParents, context, node)
-    },
-  }
-}
-
-export default swiftwc