@adonisjs/core 7.0.0-next.11 → 7.0.0-next.12

package/build/string-CJ7ewUFq.js

@@ -0,0 +1,28 @@
+import prettyHrTime from "pretty-hrtime";
+import string from "@poppinss/utils/string";
+import he from "he";
+import StringBuilder from "@poppinss/utils/string_builder";
+var string_default = {
+	...string,
+	toSentence: string.sentence,
+	ordinalize: string.ordinal,
+	generateRandom: string.random,
+	create(value) {
+		return new StringBuilder(value);
+	},
+	prettyHrTime(time, options) {
+		return prettyHrTime(time, options);
+	},
+	isEmpty(value) {
+		return value.trim().length === 0;
+	},
+	escapeHTML(value, options) {
+		value = he.escape(value);
+		if (options && options.encodeSymbols) value = this.encodeSymbols(value, { allowUnsafeSymbols: true });
+		return value;
+	},
+	encodeSymbols(value, options) {
+		return he.encode(value, options);
+	}
+};
+export { string_default as t };

package/build/test_utils-c_TEaEHW.js

@@ -0,0 +1,10 @@
+import { t as Ignitor } from "./main-BTUXw6He.js";
+import { t as IgnitorFactory } from "./ignitor-Dil-rtCo.js";
+import { t as TestUtils } from "./main-2-nm3TiB.js";
+var TestUtilsFactory = class {
+	create(ignitorOrAppRoot, options) {
+		if (ignitorOrAppRoot instanceof Ignitor) return new TestUtils(ignitorOrAppRoot.createApp("test"));
+		return new TestUtils(new IgnitorFactory().withCoreConfig().withCoreProviders().create(ignitorOrAppRoot, options).createApp("console"));
+	}
+};
+export { TestUtilsFactory as t };

package/build/toolkit/main.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { t as __decorate } from "../decorate-DM0Sx1ye.js";
+import { BaseCommand, HelpCommand, IndexGenerator, Kernel, ListLoader, args } from "@adonisjs/ace";
+import { join } from "node:path";
+var IndexCommand = class extends BaseCommand {
+	static commandName = "index";
+	static description = "Create an index of commands along with a lazy loader";
+	async run() {
+		await new IndexGenerator(join(process.cwd(), this.commandsDir)).generate();
+	}
+};
+__decorate([args.string({ description: "Relative path from cwd to the commands directory" })], IndexCommand.prototype, "commandsDir", void 0);
+const kernel = Kernel.create();
+kernel.addLoader(new ListLoader([IndexCommand]));
+kernel.defineFlag("help", {
+	type: "boolean",
+	description: HelpCommand.description
+});
+kernel.on("help", async (command, $kernel, parsed) => {
+	parsed.args.unshift(command.commandName);
+	await new HelpCommand($kernel, parsed, kernel.ui, kernel.prompt).exec();
+	return $kernel.shortcircuit();
+});
+await kernel.handle(process.argv.splice(2));
+export {};

package/build/utils-CNQ4tlGM.js

@@ -0,0 +1,41 @@
+async function importAssembler(app) {
+	try {
+		return await app.import("@adonisjs/assembler");
+	} catch {}
+}
+async function importTypeScript(app) {
+	try {
+		return await app.importDefault("typescript");
+	} catch {}
+}
+async function outputTransformerDataObjects(transformersList, buffer, withSharedProps) {
+	const importsBuffer = buffer.create();
+	importsBuffer.write(`import type { InferData, InferVariants } from '@adonisjs/core/types/transformers'`);
+	if (withSharedProps) importsBuffer.write(`import type { InferSharedProps } from '@adonisjs/inertia/types'`);
+	buffer.writeLine(importsBuffer);
+	buffer.write("export namespace Data {").indent();
+	function generateNamespaceTree(input, parents) {
+		Object.keys(input).forEach((key) => {
+			const value = input[key];
+			if (typeof value === "string") {
+				const importName = `${parents.join()}${key}Transformer`;
+				importsBuffer.write(`import type ${importName} from '${value}'`);
+				buffer.write(`export type ${key} = InferData<${importName}>`);
+				buffer.write(`export namespace ${key} {`).indent();
+				buffer.write(`export type Variants = InferVariants<${importName}>`);
+				buffer.dedent().write("}");
+			} else {
+				buffer.write(`export namespace ${key} {`).indent();
+				generateNamespaceTree(value, [...parents, key]);
+				buffer.dedent().write(`}`);
+			}
+		});
+	}
+	generateNamespaceTree(transformersList, []);
+	if (withSharedProps) {
+		importsBuffer.write(`import type InertiaMiddleware from '#middleware/inertia_middleware'`);
+		buffer.write("export type SharedProps = InferSharedProps<InertiaMiddleware>");
+	}
+	buffer.dedent().write("}");
+}
+export { importTypeScript as n, outputTransformerDataObjects as r, importAssembler as t };

package/build/verification_token-DXsW81rl.js

@@ -0,0 +1,46 @@
+import string from "@poppinss/utils/string";
+import base64 from "@poppinss/utils/base64";
+import { Secret, safeEqual } from "@poppinss/utils";
+import { createHash } from "node:crypto";
+var VerificationToken = class {
+	static decode(value) {
+		if (typeof value !== "string") return null;
+		if (!value) return null;
+		const [identifier, ...tokenValue] = value.split(".");
+		if (!identifier || tokenValue.length === 0) return null;
+		const decodedIdentifier = base64.urlDecode(identifier);
+		const decodedSecret = base64.urlDecode(tokenValue.join("."));
+		if (!decodedIdentifier || !decodedSecret) return null;
+		return {
+			identifier: decodedIdentifier,
+			secret: new Secret(decodedSecret)
+		};
+	}
+	static createTransientToken(userId, size, expiresIn) {
+		const expiresAt = /* @__PURE__ */ new Date();
+		expiresAt.setSeconds(expiresAt.getSeconds() + string.seconds.parse(expiresIn));
+		return {
+			userId,
+			expiresAt,
+			...this.seed(size)
+		};
+	}
+	static seed(size) {
+		const secret = new Secret(string.random(size));
+		return {
+			secret,
+			hash: createHash("sha256").update(secret.release()).digest("hex")
+		};
+	}
+	computeValue(secret) {
+		this.value = new Secret(`${base64.urlEncode(String(this.identifier))}.${base64.urlEncode(secret.release())}`);
+	}
+	isExpired() {
+		return this.expiresAt < /* @__PURE__ */ new Date();
+	}
+	verify(secret) {
+		const newHash = createHash("sha256").update(secret.release()).digest("hex");
+		return safeEqual(this.hash, newHash);
+	}
+};
+export { VerificationToken as t };

package/build/vine-Bt4ymkM0.js

@@ -0,0 +1,32 @@
+import vine, { BaseLiteralType, symbols } from "@vinejs/vine";
+const MULTIPART_FILE = symbols.SUBTYPE ?? Symbol.for("subtype");
+function isBodyParserFile(file) {
+	return !!(file && typeof file === "object" && "isMultipartFile" in file);
+}
+const isMultipartFile = vine.createRule((file, options, field) => {
+	if (!isBodyParserFile(file)) {
+		field.report("The {{ field }} must be a file", "file", field);
+		return false;
+	}
+	const validationOptions = typeof options === "function" ? options(field) : options;
+	if (file.sizeLimit === void 0 && validationOptions.size) file.sizeLimit = validationOptions.size;
+	if (file.allowedExtensions === void 0 && validationOptions.extnames) file.allowedExtensions = validationOptions.extnames;
+	file.validate();
+	file.errors.forEach((error) => {
+		field.report(error.message, `file.${error.type}`, field, validationOptions);
+	});
+	return file.isValid;
+});
+var VineMultipartFile = class VineMultipartFile extends BaseLiteralType {
+	#validationOptions;
+	[MULTIPART_FILE] = "multipartFile";
+	constructor(validationOptions, options, validations) {
+		super(options, validations || []);
+		this.#validationOptions = validationOptions;
+		this.dataTypeValidator = isMultipartFile(validationOptions || {});
+	}
+	clone() {
+		return new VineMultipartFile(this.#validationOptions, this.cloneOptions(), this.cloneValidations());
+	}
+};
+export { VineMultipartFile as t };

package/package.json

@@ -1,24 +1,16 @@
 {
   "name": "@adonisjs/core",
   "description": "Core of AdonisJS",
-  "version": "7.0.0-next.11",
+  "version": "7.0.0-next.12",
   "engines": {
     "node": ">=24.0.0"
   },
   "main": "build/index.js",
   "type": "module",
   "files": [
-    "build/modules",
-    "build/commands",
-    "build/providers",
-    "build/services",
-    "build/factories",
-    "build/toolkit",
-    "build/types",
-    "build/src",
-    "build/stubs",
-    "build/index.d.ts",
-    "build/index.js"
+    "build",
+    "!build/bin",
+    "!build/tests"
   ],
   "bin": {
     "adonis-kit": "./build/toolkit/main.js"
@@ -68,7 +60,7 @@
     "pretest": "npm run lint",
     "test": "cross-env NODE_DEBUG=adonisjs:core c8 npm run quick:test",
     "clean": "del-cli build",
-    "copy:templates": "copyfiles \"stubs/**/**/*.stub\" build",
+    "copy:templates": "copyfiles \"stubs/**/**/*.stub\" --up=1 build",
     "precompile": "npm run lint",
     "compile": "npm run clean && tsdown && tsc --emitDeclarationOnly --declaration",
     "postcompile": "npm run copy:templates && npm run index:commands",
@@ -231,6 +223,7 @@
       "factories/core/main.ts",
       "factories/**/*.ts",
       "src/types.ts",
+      "toolkit/main.ts",
       "types/**/*.ts",
       "services/**/*.ts",
       "providers/**/*.ts",