create-next-hydra 0.1.0 → 0.2.0

package/dist/composition/paths.js

@@ -0,0 +1,47 @@
+import path from "node:path";
+import { CompositionValidationError } from "./errors.js";
+const LEADING_CURRENT_DIRECTORY = /^\.\//;
+const REGISTRY_SOURCE_DIRECTORY = "registry";
+function normalizeRelativePath(value, label) {
+    if (value.includes("\\")) {
+        throw new CompositionValidationError("Unsafe composition path.", [
+            `${label} must use forward slashes: ${value}`,
+        ]);
+    }
+    const normalized = path.posix.normalize(value);
+    if (normalized === "." ||
+        normalized === ".." ||
+        normalized.startsWith("../") ||
+        path.posix.isAbsolute(normalized)) {
+        throw new CompositionValidationError("Unsafe composition path.", [
+            `${label} escapes or names the workspace root: ${value}`,
+        ]);
+    }
+    return normalized.replace(LEADING_CURRENT_DIRECTORY, "");
+}
+export function resolveRegistryTarget(target) {
+    if (!target.startsWith("~/")) {
+        throw new CompositionValidationError("Registry files require workspace-root targets.", [`files[].target must start with ~/: ${target}`]);
+    }
+    const relativeTarget = target.startsWith("~/") ? target.slice(2) : target;
+    return normalizeRelativePath(relativeTarget, "registry target");
+}
+export function resolveWorkspacePath(value, label) {
+    return normalizeRelativePath(value, label);
+}
+export function isManagedApplicationSource(sourcePath, target) {
+    if (!target?.startsWith("~/")) {
+        return false;
+    }
+    const normalized = path.posix
+        .normalize(sourcePath)
+        .replace(LEADING_CURRENT_DIRECTORY, "");
+    const marker = `/${REGISTRY_SOURCE_DIRECTORY}/`;
+    const sourceWithLeadingSlash = `/${normalized}`;
+    const markerIndex = sourceWithLeadingSlash.lastIndexOf(marker);
+    if (markerIndex === -1) {
+        return false;
+    }
+    return (sourceWithLeadingSlash.slice(markerIndex + marker.length) ===
+        target.slice(2));
+}

package/dist/composition/planner.d.ts

@@ -0,0 +1,4 @@
+import type { CompositionPlan, SourceRegistryCatalog, WorkspaceSelection } from "./types.js";
+export declare function planComposition(catalog: SourceRegistryCatalog, selection: WorkspaceSelection): CompositionPlan;
+export declare function selectionFromPreset(catalog: SourceRegistryCatalog, reference: string): WorkspaceSelection;
+//# sourceMappingURL=planner.d.ts.map

package/dist/composition/planner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner.d.ts","sourceRoot":"","sources":["../../src/composition/planner.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAEV,eAAe,EAIf,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAiWpB,wBAAgB,eAAe,CAC7B,OAAO,EAAE,qBAAqB,EAC9B,SAAS,EAAE,kBAAkB,GAC5B,eAAe,CAoGjB;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,qBAAqB,EAC9B,SAAS,EAAE,MAAM,GAChB,kBAAkB,CAuBpB"}

package/dist/composition/planner.js

@@ -0,0 +1,320 @@
+import { resolveCatalogSelection, resolveRegistryItemGraph, } from "./catalog.js";
+import { CompositionValidationError } from "./errors.js";
+import { mergePackageRequirements } from "./packages.js";
+import { isManagedApplicationSource, resolveRegistryTarget, resolveWorkspacePath, } from "./paths.js";
+import { PROVIDER_ALIASES, PROVIDER_SLOTS } from "./types.js";
+function uniqueSorted(values) {
+    // eslint-disable-next-line unicorn/no-array-sort -- The newly-created array is safe to sort in place.
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function itemTargets(catalog, itemName) {
+    const item = catalog.items.get(itemName);
+    if (!item) {
+        throw new CompositionValidationError("Missing registry item.", [
+            `${itemName} is not in the source registry`,
+        ]);
+    }
+    return uniqueSorted((item.files ?? []).map((file) => {
+        if (!file.target) {
+            throw new CompositionValidationError("Registry items require explicit targets.", [`${itemName}:${file.path} does not declare files[].target`]);
+        }
+        return resolveRegistryTarget(file.target);
+    }));
+}
+function itemManagedTargets(catalog, itemName) {
+    const item = catalog.items.get(itemName);
+    if (!item) {
+        throw new CompositionValidationError("Missing registry item.", [
+            `${itemName} is not in the source registry`,
+        ]);
+    }
+    return uniqueSorted((item.files ?? [])
+        .filter((file) => isManagedApplicationSource(file.path, file.target))
+        .map((file) => {
+        if (!file.target) {
+            throw new CompositionValidationError("Managed application files require explicit targets.", [`${itemName}:${file.path} does not declare files[].target`]);
+        }
+        return resolveRegistryTarget(file.target);
+    }));
+}
+function resolveProviders(catalog, selection) {
+    const providers = new Map();
+    const issues = [];
+    for (const slot of PROVIDER_SLOTS) {
+        const candidate = resolveCatalogSelection(catalog, selection.providers[slot]);
+        if (candidate.kind !== "provider" || candidate.slot !== slot) {
+            issues.push(`${selection.providers[slot]} is ${candidate.kind}${candidate.slot ? ` for ${candidate.slot}` : ""}, not a ${slot} provider`);
+            continue;
+        }
+        providers.set(slot, candidate);
+    }
+    if (issues.length > 0) {
+        throw new CompositionValidationError("Provider Slot cardinality is invalid.", issues);
+    }
+    return providers;
+}
+function resolveAddOns(catalog, references, providers) {
+    const selected = new Map();
+    const queue = references.map((reference) => resolveCatalogSelection(catalog, reference));
+    const selectedProviderIds = new Set(providers.map((provider) => provider.id));
+    const enqueueRequiredAddOns = (selection) => {
+        for (const requiredId of selection.compatibility.requires) {
+            if (selectedProviderIds.has(requiredId) || selected.has(requiredId)) {
+                continue;
+            }
+            const required = catalog.byId.get(requiredId);
+            if (required?.kind === "add-on") {
+                queue.push(required);
+            }
+        }
+    };
+    for (const provider of providers) {
+        enqueueRequiredAddOns(provider);
+    }
+    while (queue.length > 0) {
+        const candidate = queue.shift();
+        if (!candidate) {
+            continue;
+        }
+        if (candidate.kind !== "add-on") {
+            throw new CompositionValidationError("Invalid Add-on selection.", [
+                `${candidate.id} is ${candidate.kind}, not an add-on`,
+            ]);
+        }
+        if (selected.has(candidate.id)) {
+            continue;
+        }
+        selected.set(candidate.id, candidate);
+        enqueueRequiredAddOns(candidate);
+    }
+    // eslint-disable-next-line unicorn/no-array-sort -- The newly-created array is safe to sort in place.
+    return [...selected.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+function validateCompatibility(selections) {
+    const selectedIds = new Set(selections.map((selection) => selection.id));
+    const issues = [];
+    for (const selection of selections) {
+        for (const requiredId of selection.compatibility.requires) {
+            if (!selectedIds.has(requiredId)) {
+                issues.push(`${selection.id} requires ${requiredId}`);
+            }
+        }
+        for (const conflictingId of selection.compatibility.conflicts) {
+            if (selectedIds.has(conflictingId)) {
+                issues.push(`${selection.id} conflicts with ${conflictingId}`);
+            }
+        }
+    }
+    if (issues.length > 0) {
+        throw new CompositionValidationError("The requested selections are incompatible.", uniqueSorted(issues));
+    }
+}
+function validateProviderAliasRequirements(providers) {
+    const requiredLocations = {
+        auth: [
+            { cwd: "apps/api", section: "dependencies" },
+            { cwd: "apps/web", section: "dependencies" },
+            { cwd: "packages/feature-flags", section: "dependencies" },
+        ],
+        cms: [
+            { cwd: "apps/cli", section: "dependencies" },
+            { cwd: "apps/web", section: "dependencies" },
+        ],
+        commerce: [
+            { cwd: "apps/api", section: "dependencies" },
+            { cwd: "apps/cli", section: "dependencies" },
+            { cwd: "apps/web", section: "dependencies" },
+        ],
+    };
+    const issues = [];
+    for (const provider of providers) {
+        if (!provider.slot) {
+            continue;
+        }
+        const alias = PROVIDER_ALIASES[provider.slot];
+        const requiredClaims = new Set(requiredLocations[provider.slot].map((requirement) => `${requirement.cwd}\0${requirement.section}\0${alias}`));
+        const actualClaims = new Set(provider.packages.map((requirement) => `${requirement.cwd}\0${requirement.section}\0${requirement.name}`));
+        for (const claim of requiredClaims) {
+            if (!actualClaims.has(claim)) {
+                const [cwd, section, name] = claim.split("\0");
+                issues.push(`${provider.id} must declare ${cwd}/${section}.${name} for the ${provider.slot} Provider Slot`);
+            }
+        }
+    }
+    if (issues.length > 0) {
+        throw new CompositionValidationError("Providers do not supply all stable Provider aliases required by the Baseline.", uniqueSorted(issues));
+    }
+}
+function catalogPackageRequirements(catalog) {
+    const requirements = new Map();
+    for (const selection of catalog.selections) {
+        for (const requirement of selection.packages) {
+            const key = `${requirement.cwd}\0${requirement.section}\0${requirement.name}`;
+            if (!requirements.has(key)) {
+                requirements.set(key, requirement);
+            }
+        }
+    }
+    // eslint-disable-next-line unicorn/no-array-sort -- The newly-created array is safe to sort in place.
+    return [...requirements.values()].sort((left, right) => `${left.cwd}/${left.section}/${left.name}`.localeCompare(`${right.cwd}/${right.section}/${right.name}`));
+}
+function resolvePnpmPatches(selections) {
+    const patches = new Map();
+    const issues = [];
+    for (const selection of selections) {
+        for (const patch of selection.pnpmPatches) {
+            const normalized = {
+                ...patch,
+                path: resolveWorkspacePath(patch.path, `${selection.id} pnpm patch path`),
+            };
+            const existing = patches.get(normalized.dependency);
+            if (existing && existing.path !== normalized.path) {
+                issues.push(`${normalized.dependency} is patched by both ${existing.path} and ${normalized.path}`);
+            }
+            else {
+                patches.set(normalized.dependency, normalized);
+            }
+        }
+    }
+    if (issues.length > 0) {
+        throw new CompositionValidationError("pnpm patches conflict.", issues);
+    }
+    // eslint-disable-next-line unicorn/no-array-sort -- The newly-created array is safe to sort in place.
+    return [...patches.values()].sort((left, right) => left.dependency.localeCompare(right.dependency));
+}
+function catalogPnpmPatches(catalog) {
+    const patches = new Map();
+    for (const selection of catalog.selections) {
+        for (const patch of selection.pnpmPatches) {
+            const normalized = {
+                ...patch,
+                path: resolveWorkspacePath(patch.path, `${selection.id} pnpm patch path`),
+            };
+            if (!patches.has(normalized.dependency)) {
+                patches.set(normalized.dependency, normalized);
+            }
+        }
+    }
+    // eslint-disable-next-line unicorn/no-array-sort -- The newly-created array is safe to sort in place.
+    return [...patches.values()].sort((left, right) => left.dependency.localeCompare(right.dependency));
+}
+function catalogVariableTargets(catalog) {
+    return uniqueSorted([...catalog.items.values()].flatMap((item) => item.files?.map((file) => {
+        if (!file.target) {
+            throw new CompositionValidationError("Registry items require explicit targets.", [`${item.name}:${file.path} does not declare files[].target`]);
+        }
+        return resolveRegistryTarget(file.target);
+    }) ?? []));
+}
+function validateMaterializationTargets(options) {
+    const claims = new Map();
+    const issues = [];
+    const claim = (target, owner) => {
+        const existing = claims.get(target);
+        if (existing && existing !== owner) {
+            issues.push(`${target} is claimed by both ${existing} and ${owner}`);
+            return;
+        }
+        claims.set(target, owner);
+    };
+    for (const item of options.registryItems) {
+        for (const target of itemTargets(options.catalog, item)) {
+            claim(target, `registry item ${item}`);
+        }
+    }
+    for (const asset of options.assets) {
+        claim(asset.target, `asset ${asset.source}`);
+    }
+    if (issues.length > 0) {
+        throw new CompositionValidationError("Materialization targets conflict.", uniqueSorted(issues));
+    }
+}
+export function planComposition(catalog, selection) {
+    const providers = resolveProviders(catalog, selection);
+    const providerSelections = PROVIDER_SLOTS.map((slot) => {
+        const provider = providers.get(slot);
+        if (!provider) {
+            throw new CompositionValidationError("Provider Slot cardinality is invalid.", [`${slot} requires exactly one provider`]);
+        }
+        return provider;
+    });
+    const addOns = resolveAddOns(catalog, selection.addOns, providerSelections);
+    const selections = [...providerSelections, ...addOns];
+    validateProviderAliasRequirements(providerSelections);
+    validateCompatibility(selections);
+    const entryItems = uniqueSorted(selections.map((selected) => selected.itemName));
+    const registryItems = resolveRegistryItemGraph(catalog, entryItems);
+    const assets = selections
+        .flatMap((selected) => selected.assets.map((asset) => ({
+        source: resolveWorkspacePath(asset.source, `${selected.id} asset source`),
+        target: resolveWorkspacePath(asset.target, `${selected.id} asset target`),
+    })))
+        // eslint-disable-next-line unicorn/no-array-sort -- flatMap creates a fresh array.
+        .sort((left, right) => left.target.localeCompare(right.target));
+    const pnpmPatches = resolvePnpmPatches(selections);
+    const assetTargets = new Set(assets.map((asset) => asset.target));
+    const missingPatchAssets = pnpmPatches
+        .filter((patch) => !assetTargets.has(patch.path))
+        .map((patch) => `${patch.dependency} references ${patch.path}, which is not a selected asset target`);
+    if (missingPatchAssets.length > 0) {
+        throw new CompositionValidationError("pnpm patch files are missing.", missingPatchAssets);
+    }
+    validateMaterializationTargets({
+        assets,
+        catalog,
+        registryItems,
+    });
+    const managedTargets = uniqueSorted(registryItems.flatMap((item) => itemManagedTargets(catalog, item)));
+    const directlySelectedAddOnIds = new Set(selection.addOns.map((reference) => resolveCatalogSelection(catalog, reference).id));
+    const requiredAddOnIds = addOns
+        .filter((addOn) => !directlySelectedAddOnIds.has(addOn.id))
+        .map((addOn) => addOn.id);
+    return {
+        assets,
+        catalogManagedTargets: catalog.managedTargets,
+        catalogPackageRequirements: catalogPackageRequirements(catalog),
+        catalogPnpmPatches: catalogPnpmPatches(catalog),
+        entryItems,
+        instructions: [
+            ...new Set(selections
+                .map((selected) => catalog.items.get(selected.itemName)?.docs)
+                .filter((value) => Boolean(value))),
+        ],
+        managedTargets,
+        packageRequirements: mergePackageRequirements(selections),
+        pnpmPatches,
+        registryItems,
+        selection: {
+            ...selection,
+            addOns: uniqueSorted([...selection.addOns, ...requiredAddOnIds]),
+            providers: { ...selection.providers },
+        },
+        selections,
+        variableTargets: uniqueSorted([
+            ...catalogVariableTargets(catalog),
+            ...catalog.selections.flatMap((selected) => selected.assets.map((asset) => resolveWorkspacePath(asset.target, `${selected.id} asset target`))),
+        ]),
+    };
+}
+export function selectionFromPreset(catalog, reference) {
+    const preset = resolveCatalogSelection(catalog, reference);
+    if (preset.kind !== "preset" || !preset.selections?.providers) {
+        throw new CompositionValidationError("Invalid Preset selection.", [
+            `${reference} is not a complete Next Hydra preset`,
+        ]);
+    }
+    const { addOns, providers } = preset.selections;
+    if (!(providers.auth && providers.cms && providers.commerce)) {
+        throw new CompositionValidationError("Preset is incomplete.", [
+            `${preset.id} must select auth, cms, and commerce providers`,
+        ]);
+    }
+    return {
+        addOns,
+        providers: {
+            auth: providers.auth,
+            cms: providers.cms,
+            commerce: providers.commerce,
+        },
+    };
+}

package/dist/composition/schema.d.ts

@@ -0,0 +1,235 @@
+import { z } from "zod";
+export declare const NEXT_HYDRA_SELECTION_SCHEMA_URL = "https://raw.githubusercontent.com/jakala-na/next-hydra/main/packages/create-next-hydra/schema/selection-definition.json";
+export declare const selectionDefinitionSchema: z.ZodEffects<z.ZodObject<{
+    assets: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        source: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>;
+        target: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        source: string;
+        target: string;
+    }, {
+        source: string;
+        target: string;
+    }>, "many">>;
+    compatibility: z.ZodDefault<z.ZodObject<{
+        conflicts: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        requires: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        conflicts: string[];
+        requires: string[];
+    }, {
+        conflicts?: string[] | undefined;
+        requires?: string[] | undefined;
+    }>>;
+    id: z.ZodString;
+    kind: z.ZodEnum<["provider", "add-on", "preset"]>;
+    packages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        cwd: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>;
+        name: z.ZodString;
+        section: z.ZodEnum<["dependencies", "devDependencies", "optionalDependencies"]>;
+        specifier: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        cwd: string;
+        name: string;
+        section: "dependencies" | "devDependencies" | "optionalDependencies";
+        specifier: string;
+    }, {
+        cwd: string;
+        name: string;
+        section: "dependencies" | "devDependencies" | "optionalDependencies";
+        specifier: string;
+    }>, "many">>;
+    pnpmPatches: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        dependency: z.ZodString;
+        path: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>, string, string>, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        dependency: string;
+        path: string;
+    }, {
+        dependency: string;
+        path: string;
+    }>, "many">>;
+    selections: z.ZodOptional<z.ZodObject<{
+        addOns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        providers: z.ZodOptional<z.ZodObject<{
+            auth: z.ZodOptional<z.ZodString>;
+            cms: z.ZodOptional<z.ZodString>;
+            commerce: z.ZodOptional<z.ZodString>;
+        }, "strict", z.ZodTypeAny, {
+            auth?: string | undefined;
+            cms?: string | undefined;
+            commerce?: string | undefined;
+        }, {
+            auth?: string | undefined;
+            cms?: string | undefined;
+            commerce?: string | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        addOns: string[];
+        providers?: {
+            auth?: string | undefined;
+            cms?: string | undefined;
+            commerce?: string | undefined;
+        } | undefined;
+    }, {
+        addOns?: string[] | undefined;
+        providers?: {
+            auth?: string | undefined;
+            cms?: string | undefined;
+            commerce?: string | undefined;
+        } | undefined;
+    }>>;
+    slot: z.ZodOptional<z.ZodEnum<["auth", "cms", "commerce"]>>;
+}, "strict", z.ZodTypeAny, {
+    assets: {
+        source: string;
+        target: string;
+    }[];
+    compatibility: {
+        conflicts: string[];
+        requires: string[];
+    };
+    id: string;
+    kind: "add-on" | "preset" | "provider";
+    packages: {
+        cwd: string;
+        name: string;
+        section: "dependencies" | "devDependencies" | "optionalDependencies";
+        specifier: string;
+    }[];
+    pnpmPatches: {
+        dependency: string;
+        path: string;
+    }[];
+    selections?: {
+        addOns: string[];
+        providers?: {
+            auth?: string | undefined;
+            cms?: string | undefined;
+            commerce?: string | undefined;
+        } | undefined;
+    } | undefined;
+    slot?: "auth" | "cms" | "commerce" | undefined;
+}, {
+    assets?: {
+        source: string;
+        target: string;
+    }[] | undefined;
+    compatibility?: {
+        conflicts?: string[] | undefined;
+        requires?: string[] | undefined;
+    } | undefined;
+    id: string;
+    kind: "add-on" | "preset" | "provider";
+    packages?: {
+        cwd: string;
+        name: string;
+        section: "dependencies" | "devDependencies" | "optionalDependencies";
+        specifier: string;
+    }[] | undefined;
+    pnpmPatches?: {
+        dependency: string;
+        path: string;
+    }[] | undefined;
+    selections?: {
+        addOns?: string[] | undefined;
+        providers?: {
+            auth?: string | undefined;
+            cms?: string | undefined;
+            commerce?: string | undefined;
+        } | undefined;
+    } | undefined;
+    slot?: "auth" | "cms" | "commerce" | undefined;
+}>, {
+    assets: {
+        source: string;
+        target: string;
+    }[];
+    compatibility: {
+        conflicts: string[];
+        requires: string[];
+    };
+    id: string;
+    kind: "add-on" | "preset" | "provider";
+    packages: {
+        cwd: string;
+        name: string;
+        section: "dependencies" | "devDependencies" | "optionalDependencies";
+        specifier: string;
+    }[];
+    pnpmPatches: {
+        dependency: string;
+        path: string;
+    }[];
+    selections?: {
+        addOns: string[];
+        providers?: {
+            auth?: string | undefined;
+            cms?: string | undefined;
+            commerce?: string | undefined;
+        } | undefined;
+    } | undefined;
+    slot?: "auth" | "cms" | "commerce" | undefined;
+}, {
+    assets?: {
+        source: string;
+        target: string;
+    }[] | undefined;
+    compatibility?: {
+        conflicts?: string[] | undefined;
+        requires?: string[] | undefined;
+    } | undefined;
+    id: string;
+    kind: "add-on" | "preset" | "provider";
+    packages?: {
+        cwd: string;
+        name: string;
+        section: "dependencies" | "devDependencies" | "optionalDependencies";
+        specifier: string;
+    }[] | undefined;
+    pnpmPatches?: {
+        dependency: string;
+        path: string;
+    }[] | undefined;
+    selections?: {
+        addOns?: string[] | undefined;
+        providers?: {
+            auth?: string | undefined;
+            cms?: string | undefined;
+            commerce?: string | undefined;
+        } | undefined;
+    } | undefined;
+    slot?: "auth" | "cms" | "commerce" | undefined;
+}>;
+export declare const workspaceSelectionSchema: z.ZodObject<{
+    addOns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    providers: z.ZodObject<{
+        auth: z.ZodString;
+        cms: z.ZodString;
+        commerce: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        auth: string;
+        cms: string;
+        commerce: string;
+    }, {
+        auth: string;
+        cms: string;
+        commerce: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    addOns: string[];
+    providers: {
+        auth: string;
+        cms: string;
+        commerce: string;
+    };
+}, {
+    addOns?: string[] | undefined;
+    providers: {
+        auth: string;
+        cms: string;
+        commerce: string;
+    };
+}>;
+export declare function formatZodError(error: z.ZodError): string[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/composition/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/composition/schema.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,+BAA+B,4HAC+E,CAAC;AAoD5H,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2DlC,CAAC;AAEL,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW1B,CAAC;AAEZ,wBAAgB,cAAc,CAAC,KAAK,EAAE,CAAC,CAAC,QAAQ,GAAG,MAAM,EAAE,CAK1D"}