@trypattern/sdk 0.0.0-stage → 0.1.0

package/dist/rules/checkApiRouting.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/rules/checkApiRouting.js

@@ -0,0 +1,112 @@
+import { request } from 'node:http';
+import { createServer as createNetServer } from 'node:net';
+import { createServer, preview } from 'vite';
+const API_ROUTES_REACH_THE_WORKER = 'Browser navigations to /api/* (pasted links, OAuth callbacks) must reach the Hono worker, not the single-page app. Cloudflare serves index.html to navigations without running the worker unless wrangler.jsonc keeps "run_worker_first": ["/api/*"] under "assets". Without it, an OAuth callback lands on the app and loops.';
+const APP_ROUTES_SERVE_THE_APP = 'Browser navigations outside /api/ must serve the app (index.html) so deep links like /issues open the screen. Keep "not_found_handling": "single-page-application" in wrangler.jsonc and keep run_worker_first limited to /api/*.';
+const DEV_SIGN_IN_ONLY_IN_DEV = 'POST /api/auth/dev-sign-in signs anyone in without Google, so it must exist in the dev server (app sign-in, flows and screenshots use it) and must not exist in the production build. createServer in @trypattern/sdk mounts it only under import.meta.env.DEV.';
+const probes = [
+    {
+        path: '/api/health',
+        expectsJson: true,
+        rationale: API_ROUTES_REACH_THE_WORKER
+    },
+    {
+        path: '/api/auth/callback?code=check',
+        expectsJson: true,
+        rationale: API_ROUTES_REACH_THE_WORKER
+    },
+    {
+        path: '/issues',
+        expectsJson: false,
+        rationale: APP_ROUTES_SERVE_THE_APP
+    }
+];
+function freePort() {
+    return new Promise((done, fail) => {
+        const server = createNetServer();
+        server.on('error', fail);
+        server.listen(0, () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address !== null ? address.port : 0;
+            server.close(() => done(port));
+        });
+    });
+}
+function navigate(url) {
+    return new Promise((done, fail) => {
+        const sent = request(url, { headers: { 'sec-fetch-mode': 'navigate', accept: 'text/html' } }, (response) => {
+            response.resume();
+            response.on('end', () => done(response.headers['content-type'] ?? ''));
+        });
+        sent.on('error', fail);
+        sent.end();
+    });
+}
+function devSignInStatus(base) {
+    return new Promise((done, fail) => {
+        const sent = request(new URL('/api/auth/dev-sign-in', base), { method: 'POST', headers: { 'content-type': 'application/json' } }, (response) => {
+            response.resume();
+            response.on('end', () => done(response.statusCode ?? 0));
+        });
+        sent.on('error', fail);
+        sent.end('{}');
+    });
+}
+async function devSignInProblem(label, base, shouldExist) {
+    const exists = (await devSignInStatus(base)) !== 404;
+    return exists === shouldExist
+        ? []
+        : [
+            `${label}: POST /api/auth/dev-sign-in ${exists ? 'exists' : 'is missing'}.\n  ${DEV_SIGN_IN_ONLY_IN_DEV}`
+        ];
+}
+async function problemsAt(label, base) {
+    const problems = [];
+    for (const probe of probes) {
+        const contentType = await navigate(new URL(probe.path, base));
+        const isJson = !contentType.includes('text/html');
+        if (isJson !== probe.expectsJson) {
+            problems.push(`${label}: navigating to ${probe.path} returned ${contentType || 'no content type'}, expected ${probe.expectsJson ? 'a response from the worker' : 'the app (text/html)'}.\n  ${probe.rationale}`);
+        }
+    }
+    return problems;
+}
+async function devProblems() {
+    const port = await freePort();
+    const server = await createServer({
+        logLevel: 'silent',
+        server: { port, strictPort: true, open: false }
+    });
+    await server.listen();
+    try {
+        const base = `http://localhost:${port}`;
+        return [
+            ...(await problemsAt('dev server', base)),
+            ...(await devSignInProblem('dev server', base, true))
+        ];
+    }
+    finally {
+        await server.close();
+    }
+}
+async function buildProblems() {
+    const port = await freePort();
+    const server = await preview({
+        logLevel: 'silent',
+        preview: { port, strictPort: true, open: false }
+    });
+    try {
+        const base = `http://localhost:${port}`;
+        return [
+            ...(await problemsAt('production build', base)),
+            ...(await devSignInProblem('production build', base, false))
+        ];
+    }
+    finally {
+        await server.close();
+    }
+}
+const problems = [...(await devProblems()), ...(await buildProblems())];
+for (const problem of problems)
+    console.error(problem);
+process.exit(problems.length === 0 ? 0 : 1);

package/dist/rules/lintPlugin.d.ts

@@ -0,0 +1,252 @@
+type Location = {
+    start: {
+        line: number;
+        column: number;
+    };
+};
+type AstNode = {
+    type: string;
+    loc: Location;
+} & Record<string, unknown>;
+type RuleContext = {
+    filename: string;
+    options: readonly unknown[];
+    sourceCode: {
+        getAllComments: () => {
+            type: string;
+            loc: Location;
+        }[];
+    };
+    report: (problem: {
+        loc: Location;
+        message: string;
+    }) => void;
+};
+type Visitors = Record<string, (node: AstNode) => void>;
+declare const _default: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        'no-comments': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'no-pointer-cursor': {
+            meta: {
+                type: string;
+            };
+            create(context: RuleContext): Visitors;
+        };
+        'use-tokens': {
+            meta: {
+                type: string;
+            };
+            create(context: RuleContext): Visitors;
+        };
+        'no-interactive-transition': {
+            meta: {
+                type: string;
+            };
+            create(context: RuleContext): Visitors;
+        };
+        'hover-uses-highlight': {
+            meta: {
+                type: string;
+            };
+            create(context: RuleContext): Visitors;
+        };
+        'scroll-view-only': {
+            meta: {
+                type: string;
+            };
+            create(context: RuleContext): Visitors;
+        };
+        'selectable-only': {
+            meta: {
+                type: string;
+            };
+            create(context: RuleContext): Visitors;
+        };
+        'dark-mode-in-tokens': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'use-breakpoints': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'no-classname-strings': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'typed-style-prop': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'component-file-name': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'component-first': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'routes-under-app-layout': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'no-route-data-apis': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'use-link': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'stores-in-app': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'state-via-hooks': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'model-members': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'pure-getters': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'actions-where': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'pure-actions': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'use-model-where': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'model-by-name': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'classes-not-factories': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'explicit-access': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'dev-only-sign-in': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'use-primitives': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'no-widget-roles': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'no-click-on-static': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'primitive-names': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'use-space-tokens': {
+            meta: {
+                type: string;
+                schema: {
+                    type: string;
+                    properties: {
+                        sizes: {
+                            type: string;
+                        };
+                    };
+                    additionalProperties: boolean;
+                }[];
+            };
+            create(context: RuleContext): Visitors;
+        };
+        'text-via-text': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'compose-in-screens': {
+            meta: {
+                type: string;
+            };
+            create: (context: RuleContext) => Visitors;
+        };
+        'no-hover-in-app': {
+            meta: {
+                type: string;
+            };
+            create(context: RuleContext): Visitors;
+        };
+    };
+};
+export default _default;