@conorroberts/utils 0.0.35 → 0.0.37

package/dist/{env.d.ts → env.d.mts}

@@ -1,16 +1,19 @@
-import * as v from 'valibot';
+import * as v from "valibot";
+
+//#region src/env.d.ts
 
 /**
  * Validates your environment variables against the given Valibot schema;
  * @param args
  * @returns An object containing client environment variables and another containing server environment variables
  */
-declare const createEnv: <Schema extends Record<string, v.GenericSchema>, Env = { [K_1 in keyof Schema]: v.InferOutput<Schema[K_1]>; }>(args: {
-    schema: Schema;
-    env: any;
+declare const createEnv: <Schema extends Record<string, v.GenericSchema>, Env = { [K_1 in keyof Schema]: v.InferOutput<Schema[K_1]> }>(args: {
+  schema: Schema;
+  env: any;
 }) => {
-    client: { [B in Exclude<{ [K in keyof Env]: K extends `PUBLIC_${string}` ? K : never; }[keyof Env], undefined>]: Env[B]; };
-    server: Env;
+  client: { [B in Exclude<{ [K in keyof Env]: K extends `PUBLIC_${string}` ? K : never }[keyof Env], undefined>]: Env[B] };
+  server: Env;
 };
-
+//#endregion
 export { createEnv };
+//# sourceMappingURL=env.d.mts.map

package/dist/env.mjs

@@ -0,0 +1,32 @@
+import { pipe } from "remeda";
+import * as v from "valibot";
+
+//#region src/env.ts
+const PUBLIC_ENV_PREFIX = "PUBLIC_";
+/**
+* Validates your environment variables against the given Valibot schema;
+* @param args
+* @returns An object containing client environment variables and another containing server environment variables
+*/
+const createEnv = (args) => {
+	const pairs = Object.entries(args.schema);
+	const serverEnv = /* @__PURE__ */ new Map();
+	const invalidKeys = [];
+	for (const [key, value] of pairs) {
+		const result = v.safeParse(value, args.env[key] ?? null);
+		if (!result.success) invalidKeys.push(key);
+		serverEnv.set(key, result.output);
+	}
+	if (invalidKeys.length > 0) {
+		console.error(`Invalid environment variable(s): ${invalidKeys.map((e) => `"${e}"`).join(", ")}`);
+		process.exit(1);
+	}
+	return {
+		client: pipe(serverEnv, (obj) => Array.from(obj.entries()), (pairs$1) => pairs$1.filter(([k]) => k.startsWith(PUBLIC_ENV_PREFIX)), (pairs$1) => Object.fromEntries(pairs$1)),
+		server: Object.fromEntries(serverEnv.entries())
+	};
+};
+
+//#endregion
+export { createEnv };
+//# sourceMappingURL=env.mjs.map

package/dist/env.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.mjs","names":["invalidKeys: string[]","pairs"],"sources":["../src/env.ts"],"sourcesContent":["import { pipe } from \"remeda\";\nimport * as v from \"valibot\";\n\nconst PUBLIC_ENV_PREFIX = \"PUBLIC_\" as const;\n\n/**\n * Validates your environment variables against the given Valibot schema;\n * @param args\n * @returns An object containing client environment variables and another containing server environment variables\n */\nexport const createEnv = <\n  Schema extends Record<string, v.GenericSchema>,\n  Env = {\n    [K in keyof Schema]: v.InferOutput<Schema[K]>;\n  },\n>(args: {\n  schema: Schema;\n  env: any;\n}) => {\n  const pairs = Object.entries(args.schema);\n  const serverEnv = new Map();\n  const invalidKeys: string[] = [];\n\n  for (const [key, value] of pairs) {\n    const result = v.safeParse(value, args.env[key] ?? null);\n\n    if (!result.success) {\n      invalidKeys.push(key);\n    }\n\n    serverEnv.set(key, result.output);\n  }\n\n  if (invalidKeys.length > 0) {\n    console.error(`Invalid environment variable(s): ${invalidKeys.map((e) => `\"${e}\"`).join(\", \")}`);\n    process.exit(1);\n  }\n\n  type ClientEnvKeys = Exclude<\n    {\n      [K in keyof Env]: K extends `${typeof PUBLIC_ENV_PREFIX}${string}` ? K : never;\n    }[keyof Env],\n    undefined\n  >;\n\n  type ClientEnv = {\n    [B in ClientEnvKeys]: Env[B];\n  };\n\n  const clientEnv = pipe(\n    serverEnv,\n    (obj) => Array.from(obj.entries()),\n    (pairs) => pairs.filter(([k]) => k.startsWith(PUBLIC_ENV_PREFIX)),\n    (pairs) => Object.fromEntries(pairs),\n  ) as ClientEnv;\n\n  return {\n    client: clientEnv,\n    server: Object.fromEntries(serverEnv.entries()) as Env,\n  };\n};\n"],"mappings":";;;;AAGA,MAAM,oBAAoB;;;;;;AAO1B,MAAa,aAKX,SAGI;CACJ,MAAM,QAAQ,OAAO,QAAQ,KAAK,OAAO;CACzC,MAAM,4BAAY,IAAI,KAAK;CAC3B,MAAMA,cAAwB,EAAE;AAEhC,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO;EAChC,MAAM,SAAS,EAAE,UAAU,OAAO,KAAK,IAAI,QAAQ,KAAK;AAExD,MAAI,CAAC,OAAO,QACV,aAAY,KAAK,IAAI;AAGvB,YAAU,IAAI,KAAK,OAAO,OAAO;;AAGnC,KAAI,YAAY,SAAS,GAAG;AAC1B,UAAQ,MAAM,oCAAoC,YAAY,KAAK,MAAM,IAAI,EAAE,GAAG,CAAC,KAAK,KAAK,GAAG;AAChG,UAAQ,KAAK,EAAE;;AAqBjB,QAAO;EACL,QARgB,KAChB,YACC,QAAQ,MAAM,KAAK,IAAI,SAAS,CAAC,GACjC,YAAUC,QAAM,QAAQ,CAAC,OAAO,EAAE,WAAW,kBAAkB,CAAC,GAChE,YAAU,OAAO,YAAYA,QAAM,CACrC;EAIC,QAAQ,OAAO,YAAY,UAAU,SAAS,CAAC;EAChD"}

package/dist/images.d.mts

@@ -0,0 +1,79 @@
+//#region src/images.d.ts
+interface OptimizedImageOptions {
+  anim?: boolean;
+  background?: string;
+  blur?: number;
+  brightness?: number;
+  compression?: "fast";
+  contrast?: number;
+  dpr?: number;
+  fit?: "scale-down" | "contain" | "cover" | "crop" | "pad";
+  format?: "webp" | "avif" | "json";
+  gamma?: number;
+  width?: number;
+  height?: number;
+  metadata?: "keep" | "copyright" | "none";
+  quality?: number;
+  rotate?: number;
+  sharpen?: number;
+}
+interface CreateImageUrlResponse {
+  result: {
+    id: string;
+    uploadURL: string;
+  };
+  success: boolean;
+  errors: unknown[];
+  messages: unknown[];
+}
+declare class ImageUtils<ImageIds extends Record<string, any>> {
+  private blacklist;
+  private accountId;
+  private accountHash;
+  private _imageIds;
+  constructor(args: {
+    accountId: string;
+    accountHash: string;
+    blacklist?: string[];
+    imageIds?: ImageIds;
+  });
+  get imageIds(): ImageIds;
+  url(id: string): string;
+  private isBlacklisted;
+  private isProtected;
+  /**
+   * Will only operate on images that have been uploaded via cloudflare images
+   */
+  optimizeUrl(url: string, options: OptimizedImageOptions): string;
+  optimizeId(id: string, options: OptimizedImageOptions): string;
+  createOptionsSearchParams(options: OptimizedImageOptions): URLSearchParams;
+  createImageOptionsString(options: OptimizedImageOptions): string;
+  createUploadUrls(count: number, args: {
+    apiKey: string;
+  }): Promise<{
+    url: string;
+    id: string;
+  }[]>;
+  serverUpload(data: Blob, args: {
+    apiKey: string;
+  }): Promise<any>;
+  upload(url: string, body: FormData): Promise<string>;
+  delete(id: string, args: {
+    apiKey: string;
+  }): Promise<{
+    success: boolean;
+  }>;
+  batchUpload(files: {
+    file: File;
+    url: {
+      id: string;
+      value: string;
+    };
+  }[]): Promise<{
+    url: string;
+    id: string;
+  }[]>;
+}
+//#endregion
+export { CreateImageUrlResponse, ImageUtils, OptimizedImageOptions };
+//# sourceMappingURL=images.d.mts.map

package/dist/images.mjs

@@ -0,0 +1,129 @@
+import { nanoid } from "nanoid";
+import dayjs from "dayjs";
+import { ofetch } from "ofetch";
+
+//#region src/images.ts
+var ImageUtils = class {
+	blacklist = ["img.clerk.com"];
+	accountId;
+	accountHash;
+	_imageIds;
+	constructor(args) {
+		this.accountId = args.accountId;
+		this.accountHash = args.accountHash;
+		this._imageIds = args.imageIds;
+		if (args.blacklist) this.blacklist.push(...args.blacklist);
+	}
+	get imageIds() {
+		if (!this._imageIds) throw new Error("imageIds was not supplied in constructor");
+		return this._imageIds;
+	}
+	url(id) {
+		return `https://imagedelivery.net/${this.accountHash}/${id}/public`;
+	}
+	isBlacklisted(url) {
+		return this.blacklist.some((u) => url.includes(u));
+	}
+	isProtected(id) {
+		if (!this._imageIds) return false;
+		return Object.values(this._imageIds).some((e) => e === id);
+	}
+	/**
+	* Will only operate on images that have been uploaded via cloudflare images
+	*/
+	optimizeUrl(url, options) {
+		if (this.isBlacklisted(url)) return url;
+		return url.replace("public", this.createImageOptionsString(options));
+	}
+	optimizeId(id, options) {
+		return this.optimizeUrl(this.url(id), options);
+	}
+	createOptionsSearchParams(options) {
+		const params = new URLSearchParams();
+		const pairs = Object.entries(options);
+		for (const [key, val] of pairs) {
+			if (val === void 0) continue;
+			params.set(key, val.toString());
+		}
+		return params;
+	}
+	createImageOptionsString(options) {
+		const params = this.createOptionsSearchParams(options);
+		return Array.from(params.entries()).map(([key, val]) => `${key}=${val}`).join(",");
+	}
+	async createUploadUrls(count, args) {
+		if (count === 0) return [];
+		const headers = new Headers();
+		headers.set("Authorization", `Bearer ${args.apiKey}`);
+		return await Promise.all(Array.from({ length: count }).map(async () => {
+			try {
+				const form = new FormData();
+				const id = nanoid();
+				form.append("id", id);
+				form.append("expiry", dayjs().add(5, "minute").toISOString());
+				const img = await ofetch(`https://api.cloudflare.com/client/v4/accounts/${this.accountId}/images/v2/direct_upload`, {
+					method: "POST",
+					headers,
+					body: form
+				});
+				if (!img.success) throw new Error("Error uploading image");
+				return {
+					url: img.result.uploadURL,
+					id
+				};
+			} catch (e) {
+				console.error("Error uploading image");
+				throw e;
+			}
+		}));
+	}
+	async serverUpload(data, args) {
+		const formData = new FormData();
+		formData.append("file", data, nanoid());
+		const headers = new Headers();
+		headers.set("Authorization", `Bearer ${args.apiKey}`);
+		return (await fetch(`https://api.cloudflare.com/client/v4/accounts/${this.accountId}/images/v1`, {
+			method: "POST",
+			headers,
+			body: formData
+		})).json();
+	}
+	async upload(url, body) {
+		const fetchResponse = await ofetch(url, {
+			method: "POST",
+			body
+		});
+		if (!fetchResponse.success) throw new Error("Failed to upload image");
+		const downloadUrl = fetchResponse.result.variants[0];
+		if (!downloadUrl) throw new Error("Could not find download URL");
+		return downloadUrl;
+	}
+	async delete(id, args) {
+		if (this.isProtected(id)) return { success: true };
+		try {
+			const headers = new Headers();
+			headers.set("Authorization", `Bearer ${args.apiKey}`);
+			await ofetch(`https://api.cloudflare.com/client/v4/accounts/${this.accountId}/images/v1/${id}`, {
+				method: "POST",
+				headers
+			});
+			return { success: true };
+		} catch {
+			return { success: false };
+		}
+	}
+	async batchUpload(files) {
+		return await Promise.all(files.map(async (e) => {
+			const formData = new FormData();
+			formData.append("file", e.file);
+			return {
+				url: await this.upload(e.url.value, formData),
+				id: e.url.id
+			};
+		}));
+	}
+};
+
+//#endregion
+export { ImageUtils };
+//# sourceMappingURL=images.mjs.map

package/dist/images.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"images.mjs","names":[],"sources":["../src/images.ts"],"sourcesContent":["import { nanoid } from \"nanoid\";\nimport dayjs from \"dayjs\";\nimport { ofetch } from \"ofetch\";\n\nexport interface OptimizedImageOptions {\n  anim?: boolean;\n  background?: string;\n  blur?: number;\n  brightness?: number;\n  compression?: \"fast\"; // faster compression = larger file size\n  contrast?: number;\n  dpr?: number;\n  fit?: \"scale-down\" | \"contain\" | \"cover\" | \"crop\" | \"pad\";\n  format?: \"webp\" | \"avif\" | \"json\";\n  gamma?: number;\n  width?: number;\n  height?: number;\n  metadata?: \"keep\" | \"copyright\" | \"none\";\n  quality?: number;\n  rotate?: number;\n  sharpen?: number;\n}\n\nexport interface CreateImageUrlResponse {\n  result: {\n    id: string;\n    uploadURL: string;\n  };\n  success: boolean;\n  errors: unknown[];\n  messages: unknown[];\n}\n\ninterface UploadImageResponse {\n  result: {\n    id: string;\n    filename: string;\n    uploaded: string;\n    requireSignedURLs: boolean;\n    variants: string[];\n  };\n  success: boolean;\n  errors: unknown[];\n  messages: unknown[];\n}\n\nexport class ImageUtils<ImageIds extends Record<string, any>> {\n  private blacklist: string[] = [\"img.clerk.com\"];\n  private accountId: string;\n  private accountHash: string;\n  private _imageIds: ImageIds | undefined;\n\n  constructor(args: {\n    accountId: string;\n    accountHash: string;\n    blacklist?: string[];\n    imageIds?: ImageIds;\n  }) {\n    this.accountId = args.accountId;\n    this.accountHash = args.accountHash;\n\n    this._imageIds = args.imageIds;\n\n    if (args.blacklist) {\n      this.blacklist.push(...args.blacklist);\n    }\n  }\n\n  get imageIds() {\n    if (!this._imageIds) {\n      throw new Error(\"imageIds was not supplied in constructor\");\n    }\n\n    return this._imageIds;\n  }\n\n  public url(id: string) {\n    return `https://imagedelivery.net/${this.accountHash}/${id}/public`;\n  }\n\n  private isBlacklisted(url: string) {\n    return this.blacklist.some((u) => url.includes(u));\n  }\n\n  private isProtected(id: string) {\n    if (!this._imageIds) {\n      return false;\n    }\n\n    return Object.values(this._imageIds).some((e) => e === id);\n  }\n\n  /**\n   * Will only operate on images that have been uploaded via cloudflare images\n   */\n  public optimizeUrl(url: string, options: OptimizedImageOptions) {\n    if (this.isBlacklisted(url)) {\n      return url;\n    }\n\n    // Final format should look similar to: https://imagedelivery.net/<ACCOUNT_HASH>/<IMAGE_ID>/w=400,sharpen=3\n    return url.replace(\"public\", this.createImageOptionsString(options));\n  }\n\n  public optimizeId(id: string, options: OptimizedImageOptions) {\n    return this.optimizeUrl(this.url(id), options);\n  }\n\n  public createOptionsSearchParams(options: OptimizedImageOptions) {\n    const params = new URLSearchParams();\n\n    const pairs = Object.entries(options);\n\n    for (const [key, val] of pairs) {\n      if (val === undefined) {\n        continue;\n      }\n\n      params.set(key, val.toString());\n    }\n\n    return params;\n  }\n\n  public createImageOptionsString(options: OptimizedImageOptions) {\n    const params = this.createOptionsSearchParams(options);\n\n    return Array.from(params.entries())\n      .map(([key, val]) => `${key}=${val}`)\n      .join(\",\");\n  }\n\n  public async createUploadUrls(count: number, args: { apiKey: string }) {\n    if (count === 0) {\n      return [];\n    }\n\n    const headers = new Headers();\n    headers.set(\"Authorization\", `Bearer ${args.apiKey}`);\n\n    const urls = await Promise.all(\n      Array.from({ length: count }).map(async () => {\n        try {\n          const form = new FormData();\n          const id = nanoid();\n          form.append(\"id\", id);\n          form.append(\"expiry\", dayjs().add(5, \"minute\").toISOString());\n\n          const img = await ofetch<CreateImageUrlResponse>(\n            `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/images/v2/direct_upload`,\n            { method: \"POST\", headers, body: form },\n          );\n\n          if (!img.success) {\n            throw new Error(\"Error uploading image\");\n          }\n\n          return { url: img.result.uploadURL, id };\n        } catch (e) {\n          console.error(\"Error uploading image\");\n          throw e;\n        }\n      }),\n    );\n\n    return urls;\n  }\n\n  public async serverUpload(data: Blob, args: { apiKey: string }) {\n    const formData = new FormData();\n    formData.append(\"file\", data, nanoid());\n\n    const headers = new Headers();\n    headers.set(\"Authorization\", `Bearer ${args.apiKey}`);\n\n    const response = await fetch(`https://api.cloudflare.com/client/v4/accounts/${this.accountId}/images/v1`, {\n      method: \"POST\",\n      headers,\n      body: formData,\n    });\n\n    return response.json();\n  }\n\n  public async upload(url: string, body: FormData) {\n    const fetchResponse = await ofetch<UploadImageResponse>(url, {\n      method: \"POST\",\n      body,\n    });\n\n    if (!fetchResponse.success) {\n      throw new Error(\"Failed to upload image\");\n    }\n\n    const downloadUrl = fetchResponse.result.variants[0];\n\n    if (!downloadUrl) {\n      throw new Error(\"Could not find download URL\");\n    }\n\n    return downloadUrl;\n  }\n\n  public async delete(id: string, args: { apiKey: string }) {\n    if (this.isProtected(id)) {\n      return { success: true };\n    }\n\n    try {\n      const headers = new Headers();\n      headers.set(\"Authorization\", `Bearer ${args.apiKey}`);\n\n      await ofetch(`https://api.cloudflare.com/client/v4/accounts/${this.accountId}/images/v1/${id}`, {\n        method: \"POST\",\n        headers,\n      });\n      return { success: true };\n    } catch {\n      return { success: false };\n    }\n  }\n\n  public async batchUpload(files: { file: File; url: { id: string; value: string } }[]) {\n    return await Promise.all(\n      files.map(async (e) => {\n        const formData = new FormData();\n        formData.append(\"file\", e.file);\n\n        const downloadUrl = await this.upload(e.url.value, formData);\n\n        return {\n          url: downloadUrl,\n          id: e.url.id,\n        };\n      }),\n    );\n  }\n}\n"],"mappings":"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"}

package/dist/oxlint/jsx-component-pascal-case.d.mts

@@ -0,0 +1,25 @@
+import * as oxlint35 from "oxlint";
+
+//#region src/oxlint-plugins/jsx-component-pascal-case.d.ts
+declare const jsxComponentPascalCaseRule: oxlint35.Rule;
+declare namespace _default {
+  namespace meta {
+    let name: string;
+  }
+  let rules: {
+    "jsx-component-pascal-case": oxlint35.Rule;
+  };
+}
+type RuleContext = oxlint35.Context;
+type ESTNode = oxlint35.ESTree.Node;
+type ESTExpression = oxlint35.ESTree.Expression;
+type ReturnStatementNode = oxlint35.ESTree.ReturnStatement;
+type FunctionLikeNode = oxlint35.ESTree.Function | oxlint35.ESTree.ArrowFunctionExpression;
+type FunctionContext = {
+  node: FunctionLikeNode;
+  name: string;
+  returnsJsx: boolean;
+};
+//#endregion
+export { ESTExpression, ESTNode, FunctionContext, FunctionLikeNode, ReturnStatementNode, RuleContext, _default as default, jsxComponentPascalCaseRule };
+//# sourceMappingURL=jsx-component-pascal-case.d.mts.map

package/dist/oxlint/jsx-component-pascal-case.mjs

@@ -0,0 +1,159 @@
+import { defineRule } from "oxlint";
+
+//#region src/oxlint-plugins/jsx-component-pascal-case.js
+/**
+* @typedef {import("oxlint").Context} RuleContext
+* @typedef {import("oxlint").ESTree.Node} ESTNode
+* @typedef {import("oxlint").ESTree.Expression} ESTExpression
+* @typedef {import("oxlint").ESTree.ReturnStatement} ReturnStatementNode
+* @typedef {import("oxlint").ESTree.Function | import("oxlint").ESTree.ArrowFunctionExpression} FunctionLikeNode
+*/
+/**
+* @typedef {object} FunctionContext
+* @property {FunctionLikeNode} node
+* @property {string} name
+* @property {boolean} returnsJsx
+*/
+const JSX_NODE_TYPES = new Set(["JSXElement", "JSXFragment"]);
+const FUNCTION_NODE_TYPES = new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+/**
+* @param {unknown} node
+* @returns {node is ESTNode & { type: string }}
+*/
+const isNode = (node) => Boolean(node && typeof node === "object" && "type" in node);
+/**
+* @param {unknown} node
+* @returns {node is FunctionLikeNode}
+*/
+const isFunctionLike = (node) => isNode(node) && FUNCTION_NODE_TYPES.has(node.type);
+/**
+* @param {unknown} name
+* @returns {name is string}
+*/
+const isPascalCase = (name) => typeof name === "string" && /^[A-Z]/.test(name);
+/**
+* Check if a name is a valid higher-order component name (starts with "with")
+* @param {unknown} name
+* @returns {name is string}
+*/
+const isHOCName = (name) => typeof name === "string" && /^with[A-Z]/.test(name);
+/**
+* @param {FunctionLikeNode} node
+*/
+const getFunctionName = (node) => {
+	if (node.type === "FunctionDeclaration" && node.id && node.id.type === "Identifier") return node.id.name;
+	if ((node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") && node.id) {
+		if (node.id.type === "Identifier") return node.id.name;
+	}
+	const parent = node.parent;
+	if (!parent || !isNode(parent)) return "";
+	if (parent.type === "VariableDeclarator") return parent.id && parent.id.type === "Identifier" ? parent.id.name : "";
+	if (parent.type === "AssignmentExpression") return parent.left && parent.left.type === "Identifier" ? parent.left.name : "";
+	if (parent.type === "Property" || parent.type === "MethodDefinition") return "";
+	if (parent.type === "CallExpression") {
+		const callParent = parent.parent;
+		if (callParent && isNode(callParent)) {
+			if (callParent.type === "VariableDeclarator") return callParent.id && callParent.id.type === "Identifier" ? callParent.id.name : "";
+			if (callParent.type === "AssignmentExpression") return callParent.left && callParent.left.type === "Identifier" ? callParent.left.name : "";
+		}
+	}
+	return "";
+};
+/**
+* @param {ESTExpression | null | undefined} root
+*/
+const expressionContainsJsx = (root) => {
+	if (!root || !isNode(root)) return false;
+	const stack = [root];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current || !isNode(current)) continue;
+		if (JSX_NODE_TYPES.has(current.type)) return true;
+		if (FUNCTION_NODE_TYPES.has(current.type) && current !== root) continue;
+		for (const key of Object.keys(current)) {
+			if (key === "parent") continue;
+			const value = current[key];
+			if (!value) continue;
+			if (Array.isArray(value)) {
+				for (const element of value) if (isNode(element)) stack.push(element);
+			} else if (isNode(value)) stack.push(value);
+		}
+	}
+	return false;
+};
+const rule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforce PascalCase naming for functions that return JSX elements (components).",
+			recommended: false
+		},
+		schema: []
+	},
+	createOnce(context) {
+		/** @type {FunctionContext[]} */
+		const functionStack = [];
+		const currentFunction = () => functionStack[functionStack.length - 1] ?? null;
+		/**
+		* @param {FunctionLikeNode} node
+		*/
+		const enterFunction = (node) => {
+			/** @type {FunctionContext} */
+			const fnCtx = {
+				node,
+				name: getFunctionName(node),
+				returnsJsx: false
+			};
+			functionStack.push(fnCtx);
+			if (node.type === "ArrowFunctionExpression" && node.body && node.body.type !== "BlockStatement") {
+				if (expressionContainsJsx(node.body)) fnCtx.returnsJsx = true;
+			}
+		};
+		const exitFunction = () => {
+			const fnCtx = functionStack.pop();
+			if (!fnCtx) return;
+			if (fnCtx.returnsJsx && fnCtx.name && !isPascalCase(fnCtx.name) && !isHOCName(fnCtx.name)) context.report({
+				node: fnCtx.node,
+				message: `Function '${fnCtx.name}' returns JSX and should use PascalCase naming (e.g., '${fnCtx.name.charAt(0).toUpperCase()}${fnCtx.name.slice(1)}').`
+			});
+		};
+		/** @param {ReturnStatementNode} node */
+		const handleReturnStatement = (node) => {
+			const fnCtx = currentFunction();
+			if (!fnCtx) return;
+			const argument = node.argument;
+			if (!argument || isFunctionLike(argument)) return;
+			if (expressionContainsJsx(argument)) fnCtx.returnsJsx = true;
+		};
+		return {
+			FunctionDeclaration(node) {
+				if (isFunctionLike(node)) enterFunction(node);
+			},
+			"FunctionDeclaration:exit": exitFunction,
+			FunctionExpression(node) {
+				if (isFunctionLike(node)) enterFunction(node);
+			},
+			"FunctionExpression:exit": exitFunction,
+			ArrowFunctionExpression(node) {
+				if (isFunctionLike(node)) enterFunction(node);
+			},
+			"ArrowFunctionExpression:exit": exitFunction,
+			ReturnStatement(node) {
+				if (node.type === "ReturnStatement") handleReturnStatement(node);
+			}
+		};
+	}
+});
+const jsxComponentPascalCaseRule = rule;
+var jsx_component_pascal_case_default = {
+	meta: { name: "jsx-component-pascal-case" },
+	rules: { "jsx-component-pascal-case": rule }
+};
+
+//#endregion
+export { jsx_component_pascal_case_default as default, jsxComponentPascalCaseRule };
+//# sourceMappingURL=jsx-component-pascal-case.mjs.map

package/dist/oxlint/jsx-component-pascal-case.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-component-pascal-case.mjs","names":[],"sources":["../../src/oxlint-plugins/jsx-component-pascal-case.js"],"sourcesContent":["import { defineRule } from \"oxlint\";\r\n\r\n/**\r\n * @typedef {import(\"oxlint\").Context} RuleContext\r\n * @typedef {import(\"oxlint\").ESTree.Node} ESTNode\r\n * @typedef {import(\"oxlint\").ESTree.Expression} ESTExpression\r\n * @typedef {import(\"oxlint\").ESTree.ReturnStatement} ReturnStatementNode\r\n * @typedef {import(\"oxlint\").ESTree.Function | import(\"oxlint\").ESTree.ArrowFunctionExpression} FunctionLikeNode\r\n */\r\n\r\n/**\r\n * @typedef {object} FunctionContext\r\n * @property {FunctionLikeNode} node\r\n * @property {string} name\r\n * @property {boolean} returnsJsx\r\n */\r\n\r\nconst JSX_NODE_TYPES = new Set([\"JSXElement\", \"JSXFragment\"]);\r\nconst FUNCTION_NODE_TYPES = new Set([\"FunctionDeclaration\", \"FunctionExpression\", \"ArrowFunctionExpression\"]);\r\n\r\n/**\r\n * @param {unknown} node\r\n * @returns {node is ESTNode & { type: string }}\r\n */\r\nconst isNode = (node) => Boolean(node && typeof node === \"object\" && \"type\" in node);\r\n\r\n/**\r\n * @param {unknown} node\r\n * @returns {node is FunctionLikeNode}\r\n */\r\nconst isFunctionLike = (node) => isNode(node) && FUNCTION_NODE_TYPES.has(node.type);\r\n\r\n/**\r\n * @param {unknown} name\r\n * @returns {name is string}\r\n */\r\nconst isPascalCase = (name) => typeof name === \"string\" && /^[A-Z]/.test(name);\r\n\r\n/**\r\n * Check if a name is a valid higher-order component name (starts with \"with\")\r\n * @param {unknown} name\r\n * @returns {name is string}\r\n */\r\nconst isHOCName = (name) => typeof name === \"string\" && /^with[A-Z]/.test(name);\r\n\r\n/**\r\n * @param {FunctionLikeNode} node\r\n */\r\nconst getFunctionName = (node) => {\r\n  if (node.type === \"FunctionDeclaration\" && node.id && node.id.type === \"Identifier\") {\r\n    return node.id.name;\r\n  }\r\n\r\n  if ((node.type === \"FunctionExpression\" || node.type === \"ArrowFunctionExpression\") && node.id) {\r\n    if (node.id.type === \"Identifier\") return node.id.name;\r\n  }\r\n\r\n  const parent = node.parent;\r\n  if (!parent || !isNode(parent)) return \"\";\r\n\r\n  if (parent.type === \"VariableDeclarator\") {\r\n    return parent.id && parent.id.type === \"Identifier\" ? parent.id.name : \"\";\r\n  }\r\n\r\n  if (parent.type === \"AssignmentExpression\") {\r\n    return parent.left && parent.left.type === \"Identifier\" ? parent.left.name : \"\";\r\n  }\r\n\r\n  // Don't enforce naming for functions used as object property values or JSX props\r\n  // These are often callbacks or configuration options, not standalone components\r\n  if (parent.type === \"Property\" || parent.type === \"MethodDefinition\") {\r\n    return \"\";\r\n  }\r\n\r\n  // Handle functions passed as arguments to calls (e.g., useCallback, useMemo)\r\n  if (parent.type === \"CallExpression\") {\r\n    const callParent = parent.parent;\r\n    if (callParent && isNode(callParent)) {\r\n      if (callParent.type === \"VariableDeclarator\") {\r\n        return callParent.id && callParent.id.type === \"Identifier\" ? callParent.id.name : \"\";\r\n      }\r\n      if (callParent.type === \"AssignmentExpression\") {\r\n        return callParent.left && callParent.left.type === \"Identifier\" ? callParent.left.name : \"\";\r\n      }\r\n    }\r\n  }\r\n\r\n  return \"\";\r\n};\r\n\r\n/**\r\n * @param {ESTExpression | null | undefined} root\r\n */\r\nconst expressionContainsJsx = (root) => {\r\n  if (!root || !isNode(root)) return false;\r\n\r\n  const stack = [root];\r\n\r\n  while (stack.length > 0) {\r\n    const current = stack.pop();\r\n    if (!current || !isNode(current)) continue;\r\n\r\n    if (JSX_NODE_TYPES.has(current.type)) {\r\n      return true;\r\n    }\r\n\r\n    if (FUNCTION_NODE_TYPES.has(current.type) && current !== root) {\r\n      continue;\r\n    }\r\n\r\n    for (const key of Object.keys(current)) {\r\n      if (key === \"parent\") continue;\r\n\r\n      const value = current[key];\r\n      if (!value) continue;\r\n\r\n      if (Array.isArray(value)) {\r\n        for (const element of value) {\r\n          if (isNode(element)) {\r\n            stack.push(element);\r\n          }\r\n        }\r\n      } else if (isNode(value)) {\r\n        stack.push(value);\r\n      }\r\n    }\r\n  }\r\n\r\n  return false;\r\n};\r\n\r\nconst rule = defineRule({\r\n  meta: {\r\n    type: \"problem\",\r\n    docs: {\r\n      description: \"Enforce PascalCase naming for functions that return JSX elements (components).\",\r\n      recommended: false,\r\n    },\r\n    schema: [],\r\n  },\r\n\r\n  createOnce(context) {\r\n    /** @type {FunctionContext[]} */\r\n    const functionStack = [];\r\n\r\n    const currentFunction = () => functionStack[functionStack.length - 1] ?? null;\r\n\r\n    /**\r\n     * @param {FunctionLikeNode} node\r\n     */\r\n    const enterFunction = (node) => {\r\n      const name = getFunctionName(node);\r\n\r\n      /** @type {FunctionContext} */\r\n      const fnCtx = {\r\n        node,\r\n        name,\r\n        returnsJsx: false,\r\n      };\r\n\r\n      functionStack.push(fnCtx);\r\n\r\n      if (node.type === \"ArrowFunctionExpression\" && node.body && node.body.type !== \"BlockStatement\") {\r\n        if (expressionContainsJsx(node.body)) {\r\n          fnCtx.returnsJsx = true;\r\n        }\r\n      }\r\n    };\r\n\r\n    const exitFunction = () => {\r\n      const fnCtx = functionStack.pop();\r\n      if (!fnCtx) return;\r\n\r\n      // Allow PascalCase or HOC naming (withXxx)\r\n      if (fnCtx.returnsJsx && fnCtx.name && !isPascalCase(fnCtx.name) && !isHOCName(fnCtx.name)) {\r\n        context.report({\r\n          node: fnCtx.node,\r\n          message: `Function '${fnCtx.name}' returns JSX and should use PascalCase naming (e.g., '${fnCtx.name.charAt(0).toUpperCase()}${fnCtx.name.slice(1)}').`,\r\n        });\r\n      }\r\n    };\r\n\r\n    /** @param {ReturnStatementNode} node */\r\n    const handleReturnStatement = (node) => {\r\n      const fnCtx = currentFunction();\r\n      if (!fnCtx) return;\r\n\r\n      const argument = node.argument;\r\n      if (!argument || isFunctionLike(argument)) return;\r\n\r\n      if (expressionContainsJsx(argument)) {\r\n        fnCtx.returnsJsx = true;\r\n      }\r\n    };\r\n\r\n    return /** @type {import(\"oxlint\").VisitorWithHooks} */ ({\r\n      FunctionDeclaration(node) {\r\n        if (isFunctionLike(node)) enterFunction(node);\r\n      },\r\n      \"FunctionDeclaration:exit\": exitFunction,\r\n      FunctionExpression(node) {\r\n        if (isFunctionLike(node)) enterFunction(node);\r\n      },\r\n      \"FunctionExpression:exit\": exitFunction,\r\n      ArrowFunctionExpression(node) {\r\n        if (isFunctionLike(node)) enterFunction(node);\r\n      },\r\n      \"ArrowFunctionExpression:exit\": exitFunction,\r\n      ReturnStatement(node) {\r\n        if (node.type === \"ReturnStatement\") handleReturnStatement(node);\r\n      },\r\n    });\r\n  },\r\n});\r\n\r\nexport const jsxComponentPascalCaseRule = rule;\r\n\r\nexport default {\r\n  meta: { name: \"jsx-component-pascal-case\" },\r\n  rules: { \"jsx-component-pascal-case\": rule },\r\n};\r\n"],"mappings":"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"}

package/dist/oxlint/no-component-date-instantiation.d.mts

@@ -0,0 +1,27 @@
+import * as oxlint2 from "oxlint";
+
+//#region src/oxlint-plugins/no-component-date-instantiation.d.ts
+declare const noComponentDateInstantiationRule: oxlint2.Rule;
+declare namespace _default {
+  namespace meta {
+    let name: string;
+  }
+  let rules: {
+    "no-component-date-instantiation": oxlint2.Rule;
+  };
+}
+type RuleContext = oxlint2.Context;
+type ESTNode = oxlint2.ESTree.Node;
+type NewExpressionNode = oxlint2.ESTree.NewExpression;
+type ReturnStatementNode = oxlint2.ESTree.ReturnStatement;
+type FunctionLikeNode = oxlint2.ESTree.Function | oxlint2.ESTree.ArrowFunctionExpression;
+type FunctionContext = {
+  node: FunctionLikeNode;
+  parent: FunctionContext | null;
+  name: string;
+  returnsJsx: boolean;
+  dateInstantiations: NewExpressionNode[];
+};
+//#endregion
+export { ESTNode, FunctionContext, FunctionLikeNode, NewExpressionNode, ReturnStatementNode, RuleContext, _default as default, noComponentDateInstantiationRule };
+//# sourceMappingURL=no-component-date-instantiation.d.mts.map