@wasp.sh/wasp-cli-darwin-arm64-unknown 0.23.0 → 0.24.0-rc.2

package/data/packages/spec/dist/src/spec/publicApi/waspSpec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"waspSpec.d.ts","sourceRoot":"","sources":["../../../../src/spec/publicApi/waspSpec.ts"],"names":[],"mappings":"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"}

package/data/packages/spec/dist/src/spec/publicApi/waspSpec.js

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

package/data/packages/spec/dist/src/spec/refObject.d.ts

@@ -0,0 +1,95 @@
+import type * as AppSpec from "../appSpec.js";
+import type { Branded } from "../branded.js";
+/**
+ * A reference to code in your app's `src` directory.
+ *
+ * @category References
+ */
+export type RefObject = Branded<RefObjectDescriptor & {
+    kind: "refObject";
+}, "RefObject">;
+/**
+ * Input accepted by {@link ref}.
+ *
+ * @category References
+ */
+export type RefObjectDescriptor = NamedRefObjectDescriptor | DefaultRefObjectDescriptor;
+/**
+ * Named import reference, equivalent to
+ * `import { SomeValue } from "./src/someModule" with { type: "ref" }`.
+ *
+ * @category References
+ */
+export interface NamedRefObjectDescriptor {
+    /** Exported name to import. */
+    import: string;
+    /**
+     * Optional local alias.
+     *
+     * Alias takes precedence over the `import` field when
+     * Wasp Spec dervies some {@link WaspSpec.SpecElement} name.
+     */
+    alias?: string;
+    /** Module path, relative to the `*.wasp.ts` file using it. */
+    from: string;
+}
+/**
+ * Default import reference, equivalent to
+ * `import SomeValue from "./src/someModule" with { type: "ref" }`.
+ *
+ * @category References
+ */
+export interface DefaultRefObjectDescriptor {
+    /** Local name for the default import. */
+    importDefault: string;
+    /** Module path, relative to the `*.wasp.ts` file using it. */
+    from: string;
+}
+/**
+ * Creates a fallback reference object for a value from your app.
+ *
+ * {@include ./publicApi/referenceImports.md}
+ *
+ * Reference imports are preferred because editors can follow and rename real
+ * imports.
+ *
+ * The import path must be relative to the `*.wasp.ts` file where it is used
+ * and resolve inside the app's `src/` directory. Absolute
+ * paths are not supported.
+ *
+ * @category References
+ *
+ * @example
+ * ```ts
+ * import { page, ref } from "@wasp.sh/spec"
+ *
+ * const MainPage = ref({
+ *   importDefault: "MainPage",
+ *   from: "./src/MainPage",
+ * })
+ *
+ * export const mainPage = page(MainPage)
+ * ```
+ */
+export declare function ref(_descriptor: RefObjectDescriptor): RefObject;
+/**
+ * Creates a `ref` helper bound to the user's `.wasp.ts` file.
+ *
+ * Ref objects need the current spec file location to resolve relative paths,
+ * but `ref` itself can't use `import.meta.url` because it would point to this
+ * helper module. `_waspMakeRef(sourceFilePath)` lets each `.wasp.ts` file
+ * create a local `ref` that carries its own source file path.
+ *
+ * @internal
+ */
+export declare function _waspMakeRef(sourceFilePath: string): (descriptor: RefObjectDescriptor) => SourceAwareRefObject;
+export declare function mapRefObject(refObject: unknown, { projectRootDir }: {
+    projectRootDir: string;
+}): AppSpec.ExtImport;
+export declare function getRefObjectDeclarationName(refObject: unknown): string;
+type RefObjectSource = {
+    sourceFilePath: string;
+};
+type SourceAwareRefObject = RefObject & RefObjectSource;
+export {};
+//# sourceMappingURL=refObject.d.ts.map

package/data/packages/spec/dist/src/spec/refObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refObject.d.ts","sourceRoot":"","sources":["../../../src/spec/refObject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,OAAO,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAK7C;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,CAC7B,mBAAmB,GAAG;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,EAC3C,WAAW,CACZ,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAC3B,wBAAwB,GACxB,0BAA0B,CAAC;AAE/B;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC,+BAA+B;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,MAAM,WAAW,0BAA0B;IACzC,yCAAyC;IACzC,aAAa,EAAE,MAAM,CAAC;IACtB,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,GAAG,CAAC,WAAW,EAAE,mBAAmB,GAAG,SAAS,CAI/D;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,cAAc,EAAE,MAAM,GACrB,CAAC,UAAU,EAAE,mBAAmB,KAAK,oBAAoB,CAS3D;AAED,wBAAgB,YAAY,CAC1B,SAAS,EAAE,OAAO,EAClB,EAAE,cAAc,EAAE,EAAE;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,GAC7C,OAAO,CAAC,SAAS,CAqBnB;AAED,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,CAatE;AAmBD,KAAK,eAAe,GAAG;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,KAAK,oBAAoB,GAAG,SAAS,GAAG,eAAe,CAAC"}

package/data/packages/spec/dist/src/spec/refObject.js

@@ -0,0 +1,119 @@
+import { normalizeRefObjectPath } from "./refObjectPath.js";
+import { SpecUserError } from "./specUserError.js";
+/**
+ * Creates a fallback reference object for a value from your app.
+ *
+ * {@include ./publicApi/referenceImports.md}
+ *
+ * Reference imports are preferred because editors can follow and rename real
+ * imports.
+ *
+ * The import path must be relative to the `*.wasp.ts` file where it is used
+ * and resolve inside the app's `src/` directory. Absolute
+ * paths are not supported.
+ *
+ * @category References
+ *
+ * @example
+ * ```ts
+ * import { page, ref } from "@wasp.sh/spec"
+ *
+ * const MainPage = ref({
+ *   importDefault: "MainPage",
+ *   from: "./src/MainPage",
+ * })
+ *
+ * export const mainPage = page(MainPage)
+ * ```
+ */
+export function ref(_descriptor) {
+    throw new Error("Missing Wasp transformation. The `.wasp.ts` files are not directly executable, use the Wasp CLI.");
+}
+/**
+ * Creates a `ref` helper bound to the user's `.wasp.ts` file.
+ *
+ * Ref objects need the current spec file location to resolve relative paths,
+ * but `ref` itself can't use `import.meta.url` because it would point to this
+ * helper module. `_waspMakeRef(sourceFilePath)` lets each `.wasp.ts` file
+ * create a local `ref` that carries its own source file path.
+ *
+ * @internal
+ */
+export function _waspMakeRef(sourceFilePath) {
+    return (descriptor) => {
+        const refObject = {
+            ...descriptor,
+            kind: "refObject",
+        };
+        return { ...refObject, sourceFilePath };
+    };
+}
+export function mapRefObject(refObject, { projectRootDir }) {
+    if (isNamedRefObject(refObject)) {
+        return {
+            kind: "named",
+            name: refObject.import,
+            path: mapRefObjectPath(refObject, { projectRootDir }),
+            alias: refObject.alias,
+        };
+    }
+    else if (isDefaultRefObject(refObject)) {
+        return {
+            kind: "default",
+            name: refObject.importDefault,
+            path: mapRefObjectPath(refObject, { projectRootDir }),
+        };
+    }
+    else {
+        throw new SpecUserError("Got an import in the Wasp file that we couldn't process: " +
+            JSON.stringify(refObject) +
+            '\nYou either used a value imported without `with { type: "ref" }` or didn\'t write the ref object correctly.');
+    }
+}
+export function getRefObjectDeclarationName(refObject) {
+    if (isNamedRefObject(refObject)) {
+        return refObject.alias ?? refObject.import;
+    }
+    if (isDefaultRefObject(refObject)) {
+        return refObject.importDefault;
+    }
+    throw new SpecUserError("Got an import in the Wasp file that we couldn't process: " +
+        JSON.stringify(refObject));
+}
+function mapRefObjectPath(refObject, { projectRootDir }) {
+    if (!hasSourceFilePath(refObject)) {
+        throw new SpecUserError(`Relative ref path ${JSON.stringify(refObject.from)} is missing source file information. Use \`ref(...)\` in a \`*.wasp.ts\` file.`);
+    }
+    return normalizeRefObjectPath({
+        importPath: refObject.from,
+        importingFilePath: refObject.sourceFilePath,
+        projectRootDir,
+    });
+}
+function hasSourceFilePath(value) {
+    return (isObject(value) &&
+        "sourceFilePath" in value &&
+        typeof value.sourceFilePath === "string");
+}
+function isNamedRefObject(value) {
+    return (isObject(value) &&
+        typeof value.import === "string" &&
+        typeof value.from === "string" &&
+        hasValidAlias(value) &&
+        hasRefObjectMarker(value));
+}
+function isDefaultRefObject(value) {
+    return (isObject(value) &&
+        typeof value.importDefault === "string" &&
+        typeof value.from === "string" &&
+        hasRefObjectMarker(value));
+}
+function hasRefObjectMarker(value) {
+    return value.kind === "refObject";
+}
+function hasValidAlias(value) {
+    return value.alias === undefined || typeof value.alias === "string";
+}
+function isObject(value) {
+    return Object.prototype.toString.call(value) === "[object Object]";
+}

package/data/packages/spec/dist/src/spec/refObjectPath.d.ts

@@ -0,0 +1,18 @@
+import type * as AppSpec from "../appSpec.js";
+/**
+ * Converts a relative ref object path from the user's `.wasp.ts` file into
+ * AppSpec's absolute `@src/...` path format.
+ *
+ * This keeps user-authored paths source-relative while giving the Haskell side
+ * the same project-rooted paths it already understands.
+ *
+ * For example, `./src/MainPage` from `/app/main.wasp.ts` becomes
+ * `@src/MainPage`, while `./LoginPage` from `/app/src/auth/auth.wasp.ts`
+ * becomes `@src/auth/LoginPage`.
+ */
+export declare function normalizeRefObjectPath({ importPath, importingFilePath, projectRootDir, }: {
+    importPath: string;
+    importingFilePath: string;
+    projectRootDir: string;
+}): AppSpec.ExtImport["path"];
+//# sourceMappingURL=refObjectPath.d.ts.map

package/data/packages/spec/dist/src/spec/refObjectPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refObjectPath.d.ts","sourceRoot":"","sources":["../../../src/spec/refObjectPath.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,OAAO,MAAM,eAAe,CAAC;AAG9C;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,UAAU,EACV,iBAAiB,EACjB,cAAc,GACf,EAAE;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;CACxB,GAAG,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAQ5B"}

package/data/packages/spec/dist/src/spec/refObjectPath.js

@@ -0,0 +1,79 @@
+import { realpathSync } from "node:fs";
+import * as path from "node:path/posix"; // Module paths are always `/`-delimited
+import { SpecUserError } from "./specUserError.js";
+/**
+ * Converts a relative ref object path from the user's `.wasp.ts` file into
+ * AppSpec's absolute `@src/...` path format.
+ *
+ * This keeps user-authored paths source-relative while giving the Haskell side
+ * the same project-rooted paths it already understands.
+ *
+ * For example, `./src/MainPage` from `/app/main.wasp.ts` becomes
+ * `@src/MainPage`, while `./LoginPage` from `/app/src/auth/auth.wasp.ts`
+ * becomes `@src/auth/LoginPage`.
+ */
+export function normalizeRefObjectPath({ importPath, importingFilePath, projectRootDir, }) {
+    const srcRelativePath = getValidSrcRelativePath({
+        importPath,
+        importingFilePath,
+        projectRootDir,
+    });
+    return toAppSpecExtImportPath(srcRelativePath);
+}
+function getValidSrcRelativePath({ importPath, importingFilePath, projectRootDir, }) {
+    // The bundler resolves symlinks in module ids, so we compare paths under a
+    // canonical project root. Otherwise valid in-src imports can look like they
+    // escape src/ because one path has symlinks resolved and the other does not.
+    const projectRootPath = path.resolve(projectRootDir);
+    const canonicalProjectRootPath = getCanonicalPath(projectRootPath);
+    const canonicalImportingFilePath = toCanonicalProjectPath({
+        filePath: path.resolve(importingFilePath),
+        projectRootPath,
+        canonicalProjectRootPath,
+    });
+    const importingDir = path.dirname(canonicalImportingFilePath);
+    const srcRootDir = path.resolve(canonicalProjectRootPath, "src");
+    const importedFilePath = path.resolve(importingDir, importPath);
+    const srcRelativePath = path.relative(srcRootDir, importedFilePath);
+    if (!isValidSrcRelativeFilePath(srcRelativePath)) {
+        throw new SpecUserError(`Reference import path ${JSON.stringify(importPath)} in ${JSON.stringify(importingFilePath)} must resolve to a file inside the app src/ directory.`);
+    }
+    return srcRelativePath;
+}
+function getCanonicalPath(filePath) {
+    try {
+        return realpathSync(filePath);
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return filePath;
+        }
+        throw error;
+    }
+}
+function toCanonicalProjectPath({ filePath, projectRootPath, canonicalProjectRootPath, }) {
+    const projectRelativePath = getPathInsideRoot(filePath, projectRootPath) ??
+        getPathInsideRoot(filePath, canonicalProjectRootPath);
+    return projectRelativePath !== undefined
+        ? path.resolve(canonicalProjectRootPath, projectRelativePath)
+        : filePath;
+}
+function getPathInsideRoot(filePath, rootDir) {
+    const relativePath = path.relative(rootDir, filePath);
+    return isInsideRootRelativePath(relativePath) ? relativePath : undefined;
+}
+function toAppSpecExtImportPath(srcRelativePath) {
+    return path.join("@src", srcRelativePath);
+}
+function isValidSrcRelativeFilePath(srcRelativePath) {
+    return srcRelativePath !== "" && isInsideRootRelativePath(srcRelativePath);
+}
+function isInsideRootRelativePath(relativePath) {
+    return (!startsWithParentSegment(relativePath) && !path.isAbsolute(relativePath));
+}
+function startsWithParentSegment(filePath) {
+    return filePath === ".." || filePath.startsWith(`..${path.sep}`);
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}

package/data/packages/spec/dist/src/spec/specUserError.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Error caused by invalid user input (unknown entities, bad imports, etc.).
+ *
+ * These are the errors users hit most often during development, so their
+ * messages should be short, clear, and actionable.
+ */
+export declare class SpecUserError extends Error {
+}
+//# sourceMappingURL=specUserError.d.ts.map

package/data/packages/spec/dist/src/spec/specUserError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"specUserError.d.ts","sourceRoot":"","sources":["../../../src/spec/specUserError.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,qBAAa,aAAc,SAAQ,KAAK;CAAG"}

package/data/packages/spec/dist/src/spec/specUserError.js

@@ -0,0 +1,8 @@
+/**
+ * Error caused by invalid user input (unknown entities, bad imports, etc.).
+ *
+ * These are the errors users hit most often during development, so their
+ * messages should be short, clear, and actionable.
+ */
+export class SpecUserError extends Error {
+}

package/data/packages/spec/dist/src/spec-pipeline/common.d.ts

@@ -0,0 +1,2 @@
+export declare const WASP_SPEC_FILE_REGEX: RegExp;
+//# sourceMappingURL=common.d.ts.map

package/data/packages/spec/dist/src/spec-pipeline/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/spec-pipeline/common.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,QAAgB,CAAC"}

package/data/packages/spec/dist/src/spec-pipeline/common.js

@@ -0,0 +1 @@
+export const WASP_SPEC_FILE_REGEX = /\.wasp\.ts$/;

package/data/packages/spec/dist/src/spec-pipeline/loadWaspTsSpec.d.ts

@@ -0,0 +1,5 @@
+export declare function loadWaspTsSpecDefaultExport({ specPath, tsconfigPath, }: {
+    specPath: string;
+    tsconfigPath: string;
+}): Promise<unknown>;
+//# sourceMappingURL=loadWaspTsSpec.d.ts.map

package/data/packages/spec/dist/src/spec-pipeline/loadWaspTsSpec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loadWaspTsSpec.d.ts","sourceRoot":"","sources":["../../../src/spec-pipeline/loadWaspTsSpec.ts"],"names":[],"mappings":"AAKA,wBAAsB,2BAA2B,CAAC,EAChD,QAAQ,EACR,YAAY,GACb,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,OAAO,CAAC,OAAO,CAAC,CAsBnB"}

package/data/packages/spec/dist/src/spec-pipeline/loadWaspTsSpec.js

@@ -0,0 +1,46 @@
+import { unrun } from "unrun";
+import { SpecUserError } from "../spec/specUserError.js";
+import { transformWaspTsSpecFilesPlugin } from "./transformWaspTsSpecFilesPlugin/index.js";
+import { typecheckPlugin } from "./typecheckPlugin/index.js";
+export async function loadWaspTsSpecDefaultExport({ specPath, tsconfigPath, }) {
+    const { module: specModule } = await unrun({
+        path: specPath,
+        inputOptions: {
+            plugins: [
+                transformWaspTsSpecFilesPlugin(),
+                typecheckPlugin({ tsconfigPath }),
+            ],
+        },
+        // By default, unrun will directly return the `default` export. We want to
+        // get it ourselves, so we use this option.
+        // https://gugustinette.github.io/unrun/advanced/presets.html
+        preset: "bundle-require",
+    }).catch((error) => {
+        // When a plugin throws, the bundler wraps the original error in an
+        // aggregate build error and exposes the originals on `.errors`. We dig out
+        // the `SpecUserError` so it reaches the top-level handler in `run.ts` as a
+        // clean user error instead of an internal crash.
+        throw getSpecUserError(error) ?? error;
+    });
+    return getDefaultExport(specModule);
+}
+function getSpecUserError(error) {
+    if (
+    // Checks to convince TypeScript that we can access `error.errors[0]`.
+    error instanceof Error &&
+        "errors" in error &&
+        Array.isArray(error.errors) &&
+        error.errors.length === 1 &&
+        error.errors[0] instanceof SpecUserError) {
+        return error.errors[0];
+    }
+    else {
+        return undefined;
+    }
+}
+function getDefaultExport(loadedModule) {
+    if (typeof loadedModule !== "object" || loadedModule === null) {
+        return undefined;
+    }
+    return "default" in loadedModule ? loadedModule.default : undefined;
+}

package/data/packages/spec/dist/src/spec-pipeline/transformWaspTsSpecFilesPlugin/imports/apply.d.ts

@@ -0,0 +1,4 @@
+import type { RolldownMagicString } from "rolldown";
+import type { Plan } from "./plan.js";
+export declare function applyTransformImportsPlan_mutate(magicString: RolldownMagicString, { refImports, safeRefHelperName }: Plan): void;
+//# sourceMappingURL=apply.d.ts.map

package/data/packages/spec/dist/src/spec-pipeline/transformWaspTsSpecFilesPlugin/imports/apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../../../src/spec-pipeline/transformWaspTsSpecFilesPlugin/imports/apply.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAOpD,OAAO,KAAK,EAAE,IAAI,EAAsB,MAAM,WAAW,CAAC;AAE1D,wBAAgB,gCAAgC,CAC9C,WAAW,EAAE,mBAAmB,EAChC,EAAE,UAAU,EAAE,iBAAiB,EAAE,EAAE,IAAI,GACtC,IAAI,CA0BN"}

package/data/packages/spec/dist/src/spec-pipeline/transformWaspTsSpecFilesPlugin/imports/apply.js

@@ -0,0 +1,34 @@
+import { SpecUserError } from "../../../spec/specUserError.js";
+import { buildImportStatement, PUBLIC_REF_HELPER_IMPORT_NAME, PUBLIC_REF_HELPER_IMPORT_SOURCE, } from "../util.js";
+export function applyTransformImportsPlan_mutate(magicString, { refImports, safeRefHelperName }) {
+    for (const { removeImport } of refImports) {
+        magicString.remove(removeImport.start, removeImport.end);
+    }
+    magicString.prepend([
+        // Add the `ref` helper import
+        buildImportStatement([[PUBLIC_REF_HELPER_IMPORT_NAME, safeRefHelperName]], PUBLIC_REF_HELPER_IMPORT_SOURCE),
+        // Convert each original ref import to a `const` declaration that uses the
+        // `ref` helper.
+        // In ES Modules, imports are always hoisted, so we add these declarations
+        // at the top of the file to preserve the original semantics.
+        ...refImports.flatMap(({ references }) => references.map((ref) => getLoweredImportSource(ref, {
+            refHelperName: safeRefHelperName,
+        }))),
+    ].join(""));
+}
+function getLoweredImportSource(ref, ctx) {
+    switch (ref.kind) {
+        case "named":
+            return getRefObjectBindingSource(ref.refObject.alias ?? ref.refObject.import, ref.refObject, ctx);
+        case "default":
+            return getRefObjectBindingSource(ref.refObject.importDefault, ref.refObject, ctx);
+        case "namespace":
+            throw new SpecUserError([
+                "Namespace imports are not supported for reference imports.",
+                `Replace \`import * as ${ref.alias} from "${ref.from}" with { type: "ref" }\` with a named or default reference import.`,
+            ].join("\n"));
+    }
+}
+function getRefObjectBindingSource(identifier, descriptor, { refHelperName }) {
+    return `const ${identifier} = ${refHelperName}(${JSON.stringify(descriptor)});\n`;
+}

package/data/packages/spec/dist/src/spec-pipeline/transformWaspTsSpecFilesPlugin/imports/check.d.ts

@@ -0,0 +1,3 @@
+import type { ESTree as t } from "rolldown/utils";
+export declare function assertCanTransformImports(ast: t.Program): void;
+//# sourceMappingURL=check.d.ts.map

package/data/packages/spec/dist/src/spec-pipeline/transformWaspTsSpecFilesPlugin/imports/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../../../../src/spec-pipeline/transformWaspTsSpecFilesPlugin/imports/check.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC,EAAE,MAAM,gBAAgB,CAAC;AAIlD,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,CAAC,CAAC,OAAO,GAAG,IAAI,CAO9D"}

package/data/packages/spec/dist/src/spec-pipeline/transformWaspTsSpecFilesPlugin/imports/check.js

@@ -0,0 +1,14 @@
+import { SpecUserError } from "../../../spec/specUserError.js";
+import { getStringValue } from "../util.js";
+export function assertCanTransformImports(ast) {
+    const hasRefExports = ast.body.some(isRefExportDeclaration);
+    if (hasRefExports) {
+        throw new SpecUserError("Re-exporting refs is not supported. First import the reference and then re-export it if needed.");
+    }
+}
+function isRefExportDeclaration(node) {
+    return ((node.type === "ExportNamedDeclaration" ||
+        node.type === "ExportAllDeclaration") &&
+        node.attributes.some((attr) => getStringValue(attr.key) === "type" &&
+            getStringValue(attr.value) === "ref"));
+}

package/data/packages/spec/dist/src/spec-pipeline/transformWaspTsSpecFilesPlugin/imports/index.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin, RolldownMagicString } from "rolldown";
+import type { ESTree as t } from "rolldown/utils";
+export declare function transformRefImportsPlugin(): Plugin;
+export declare function transformRefImports_mutate(ast: t.Program, magicString: RolldownMagicString): void;
+//# sourceMappingURL=index.d.ts.map

package/data/packages/spec/dist/src/spec-pipeline/transformWaspTsSpecFilesPlugin/imports/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/spec-pipeline/transformWaspTsSpecFilesPlugin/imports/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC,EAAE,MAAM,gBAAgB,CAAC;AAMlD,wBAAgB,yBAAyB,IAAI,MAAM,CA+BlD;AAED,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,CAAC,CAAC,OAAO,EACd,WAAW,EAAE,mBAAmB,GAC/B,IAAI,CAUN"}

package/data/packages/spec/dist/src/spec-pipeline/transformWaspTsSpecFilesPlugin/imports/index.js

@@ -0,0 +1,40 @@
+import assert from "node:assert/strict";
+import { WASP_SPEC_FILE_REGEX } from "../../common.js";
+import { applyTransformImportsPlan_mutate } from "./apply.js";
+import { assertCanTransformImports } from "./check.js";
+import { planTransformImports } from "./plan.js";
+export function transformRefImportsPlugin() {
+    return {
+        name: "wasp/spec/transform-ref-imports",
+        options(opts) {
+            return {
+                ...opts,
+                experimental: {
+                    ...opts.experimental,
+                    // TODO: Remove this once it goes out of experimental phase.
+                    // https://rolldown.rs/in-depth/native-magic-string
+                    nativeMagicString: true,
+                },
+            };
+        },
+        transform: {
+            filter: { id: WASP_SPEC_FILE_REGEX },
+            async handler(code, id, meta) {
+                assert(meta.magicString);
+                // If the AST is already available, use it; otherwise ask the bundler to
+                // parse it.
+                const ast = meta.ast || this.parse(code, { lang: "ts" });
+                transformRefImports_mutate(ast, meta.magicString);
+                return { code: meta.magicString };
+            },
+        },
+    };
+}
+export function transformRefImports_mutate(ast, magicString) {
+    assertCanTransformImports(ast);
+    const importsPlan = planTransformImports(ast);
+    if (!importsPlan) {
+        return;
+    }
+    applyTransformImportsPlan_mutate(magicString, importsPlan);
+}

package/data/packages/spec/dist/src/spec-pipeline/transformWaspTsSpecFilesPlugin/imports/plan.d.ts

@@ -0,0 +1,26 @@
+import type { ESTree as t } from "rolldown/utils";
+import type { DefaultRefObjectDescriptor, NamedRefObjectDescriptor } from "@wasp.sh/spec";
+export type Plan = {
+    refImports: RefImport[];
+    safeRefHelperName: string;
+};
+export type RefImportReference = {
+    kind: "named";
+    refObject: NamedRefObjectDescriptor;
+} | {
+    kind: "default";
+    refObject: DefaultRefObjectDescriptor;
+} | {
+    kind: "namespace";
+    from: string;
+    alias: string;
+};
+export interface RefImport {
+    references: RefImportReference[];
+    removeImport: {
+        start: number;
+        end: number;
+    };
+}
+export declare function planTransformImports(ast: t.Program): Plan | null;
+//# sourceMappingURL=plan.d.ts.map

package/data/packages/spec/dist/src/spec-pipeline/transformWaspTsSpecFilesPlugin/imports/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../../../src/spec-pipeline/transformWaspTsSpecFilesPlugin/imports/plan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC,EAAE,MAAM,gBAAgB,CAAC;AASlD,OAAO,KAAK,EACV,0BAA0B,EAC1B,wBAAwB,EACzB,MAAM,eAAe,CAAC;AAEvB,MAAM,MAAM,IAAI,GAAG;IACjB,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,wBAAwB,CAAA;CAAE,GACtD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,0BAA0B,CAAA;CAAE,GAC1D;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvD,MAAM,WAAW,SAAS;IACxB,UAAU,EAAE,kBAAkB,EAAE,CAAC;IACjC,YAAY,EAAE;QACZ,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;KACb,CAAC;CACH;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,CAAC,CAAC,OAAO,GAAG,IAAI,GAAG,IAAI,CAWhE"}

package/data/packages/spec/dist/src/spec-pipeline/transformWaspTsSpecFilesPlugin/imports/plan.js

@@ -0,0 +1,57 @@
+import { SpecUserError } from "../../../spec/specUserError.js";
+import { getStringValue, getTopLevelBindings, makeSafeName, PUBLIC_REF_HELPER_IMPORT_NAME, } from "../util.js";
+export function planTransformImports(ast) {
+    const refImports = findRefImports(ast);
+    if (refImports.length === 0) {
+        return null;
+    }
+    const scope = getTopLevelBindings(ast);
+    const safeRefHelperName = makeSafeName(PUBLIC_REF_HELPER_IMPORT_NAME, scope);
+    return { refImports, safeRefHelperName };
+}
+function findRefImports(ast) {
+    return ast.body.filter(isRefImportDeclaration).map((node) => {
+        const importSource = getStringValue(node.source);
+        if (node.specifiers.length === 0) {
+            throw new SpecUserError(`Ref import from ${JSON.stringify(importSource)} must import at least one binding.`);
+        }
+        return {
+            references: node.specifiers.map((specifier) => makeRefObject(importSource, specifier)),
+            removeImport: { start: node.start, end: node.end },
+        };
+    });
+}
+function isRefImportDeclaration(node) {
+    return (node.type === "ImportDeclaration" &&
+        node.attributes.some((attr) => getStringValue(attr.key) === "type" &&
+            getStringValue(attr.value) === "ref"));
+}
+function makeRefObject(importSource, specifier) {
+    switch (specifier.type) {
+        case "ImportSpecifier":
+            return {
+                kind: "named",
+                refObject: {
+                    import: getStringValue(specifier.imported),
+                    alias: getStringValue(specifier.local),
+                    from: importSource,
+                },
+            };
+        case "ImportDefaultSpecifier":
+            return {
+                kind: "default",
+                refObject: {
+                    importDefault: getStringValue(specifier.local),
+                    from: importSource,
+                },
+            };
+        case "ImportNamespaceSpecifier":
+            return {
+                kind: "namespace",
+                alias: getStringValue(specifier.local),
+                from: importSource,
+            };
+        default:
+            return specifier;
+    }
+}

package/data/packages/spec/dist/src/spec-pipeline/transformWaspTsSpecFilesPlugin/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "rolldown";
+export declare function transformWaspTsSpecFilesPlugin(): Plugin[];
+//# sourceMappingURL=index.d.ts.map