@remotion/studio-server 4.0.471 → 4.0.472

package/dist/codemods/update-keyframes/update-keyframes.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updateEffectKeyframes = exports.updateEffectKeyframesAst = exports.updateSequenceKeyframes = exports.updateSequenceKeyframesAst = void 0;
+const studio_shared_1 = require("@remotion/studio-shared");
 const recast = __importStar(require("recast"));
 const get_ast_node_path_1 = require("../../helpers/get-ast-node-path");
 const can_update_sequence_props_1 = require("../../preview-server/routes/can-update-sequence-props");
@@ -71,8 +72,7 @@ const getInterpolationExpression = (node) => {
     }
     if (node.type !== 'CallExpression' ||
         node.callee.type !== 'Identifier' ||
-        (node.callee.name !== 'interpolate' &&
-            node.callee.name !== 'interpolateColors')) {
+        !(0, studio_shared_1.isKeyframeInterpolationFunction)(node.callee.name)) {
         return null;
     }
     const frameArg = getSupportedCallArgument(node.arguments[0]);
@@ -124,14 +124,23 @@ const getInterpolationExpression = (node) => {
         keyframes,
     };
 };
-const getInterpolationCalleeForValues = ({ staticValue, newValue, }) => {
-    return b.identifier(typeof staticValue === 'string' && typeof newValue === 'string'
-        ? 'interpolateColors'
-        : 'interpolate');
+const getInterpolationCalleeForValues = ({ schema, key, staticValue, newValue, }) => {
+    return b.identifier((0, studio_shared_1.getKeyframeInterpolationFunction)({
+        schema,
+        key,
+        staticValue,
+        newValue,
+    }));
 };
 const createFrameExpression = (frame) => {
     return (0, update_nested_prop_1.parseValueExpression)(frame);
 };
+const createClampOptionsExpression = () => {
+    return b.objectExpression([
+        b.objectProperty(b.identifier('extrapolateLeft'), b.stringLiteral('clamp')),
+        b.objectProperty(b.identifier('extrapolateRight'), b.stringLiteral('clamp')),
+    ]);
+};
 const createInterpolateExpression = ({ callee, input, extraArgs, keyframes, }) => {
     const sortedKeyframes = [...keyframes].sort((first, second) => first.frame - second.frame);
     return b.callExpression(callee, [
@@ -145,10 +154,21 @@ const noIntroducedIdentifiers = {
     calleeName: null,
     needsFrameHook: false,
 };
-const addKeyframe = ({ expression, frame, value, }) => {
+const addKeyframe = ({ expression, key, frame, value, schema, }) => {
+    if (!(0, studio_shared_1.isSchemaFieldKeyframable)({ schema, key })) {
+        throw new Error(`Cannot add keyframe: "${key}" is not keyframable`);
+    }
     const existing = getInterpolationExpression(expression);
     const newOutput = (0, update_nested_prop_1.parseValueExpression)(value);
     if (existing) {
+        const existingCalleeName = existing.callee.type === 'Identifier'
+            ? existing.callee.name
+            : 'interpolate';
+        const schemaCalleeName = (0, studio_shared_1.getKeyframeInterpolationFunctionForSchemaField)({
+            schema,
+            key,
+        });
+        const nextCalleeName = schemaCalleeName !== null && schemaCalleeName !== void 0 ? schemaCalleeName : existingCalleeName;
         const existingIndex = existing.keyframes.findIndex((keyframe) => keyframe.frame === frame);
         const nextKeyframes = existingIndex === -1
             ? [...existing.keyframes, { frame, output: newOutput, value }]
@@ -157,12 +177,17 @@ const addKeyframe = ({ expression, frame, value, }) => {
                 : keyframe);
         return {
             expression: createInterpolateExpression({
-                callee: existing.callee,
+                callee: b.identifier(nextCalleeName),
                 input: existing.input,
                 extraArgs: existing.extraArgs,
                 keyframes: nextKeyframes,
             }),
-            introduced: noIntroducedIdentifiers,
+            introduced: {
+                calleeName: schemaCalleeName && schemaCalleeName !== existingCalleeName
+                    ? schemaCalleeName
+                    : null,
+                needsFrameHook: false,
+            },
         };
     }
     if (!(0, can_update_sequence_props_1.isStaticValue)(expression)) {
@@ -171,14 +196,19 @@ const addKeyframe = ({ expression, frame, value, }) => {
     const staticValue = (0, can_update_sequence_props_1.extractStaticValue)(expression);
     const keyframes = [{ frame, output: newOutput, value }];
     const callee = getInterpolationCalleeForValues({
+        schema,
+        key,
         staticValue,
         newValue: value,
     });
+    const extraArgs = callee.type === 'Identifier' && callee.name === 'interpolateColors'
+        ? []
+        : [createClampOptionsExpression()];
     return {
         expression: createInterpolateExpression({
             callee,
             input: b.identifier('frame'),
-            extraArgs: [],
+            extraArgs,
             keyframes,
         }),
         introduced: {
@@ -209,12 +239,14 @@ const removeKeyframe = ({ expression, frame, }) => {
         keyframes: nextKeyframes,
     });
 };
-const applyKeyframeOperation = ({ expression, operation, }) => {
+const applyKeyframeOperation = ({ expression, key, operation, schema, }) => {
     if (operation.type === 'add') {
         return addKeyframe({
             expression,
+            key,
             frame: operation.frame,
             value: operation.value,
+            schema,
         });
     }
     return {
@@ -267,6 +299,30 @@ const findObjectProperty = (objExpr, propertyName) => {
             : objExpr.properties[propIndex],
     };
 };
+const findFieldInSchema = (schema, key) => {
+    if (key in schema) {
+        return schema[key];
+    }
+    for (const field of Object.values(schema)) {
+        if (field.type !== 'enum') {
+            continue;
+        }
+        for (const variant of Object.values(field.variants)) {
+            const found = findFieldInSchema(variant, key);
+            if (found) {
+                return found;
+            }
+        }
+    }
+    return undefined;
+};
+const getInitialValueForMissingProp = ({ schema, key, newValue, }) => {
+    const field = schema ? findFieldInSchema(schema, key) : undefined;
+    if (field && field.type !== 'hidden' && field.default !== undefined) {
+        return field.default;
+    }
+    return newValue;
+};
 const getObjectExpression = (attr) => {
     if (!attr.value || attr.value.type !== 'JSXExpressionContainer') {
         return null;
@@ -276,11 +332,31 @@ const getObjectExpression = (attr) => {
     }
     return attr.value.expression;
 };
-const getSequenceWritableProp = ({ attributes, key, }) => {
+const createJsxExpressionAttribute = (key, expression) => {
+    return b.jsxAttribute(b.jsxIdentifier(key), b.jsxExpressionContainer(expression));
+};
+const createObjectProperty = (key, value) => b.objectProperty(b.identifier(key), value);
+const createObjectExpressionAttribute = ({ parentKey, childKey, expression, }) => {
+    return createJsxExpressionAttribute(parentKey, b.objectExpression([
+        createObjectProperty(childKey, expression),
+    ]));
+};
+const createMissingPropExpression = (missingPropInitialValue) => {
+    return (0, update_nested_prop_1.parseValueExpression)(missingPropInitialValue.value);
+};
+const getSequenceWritableProp = ({ attributes, key, missingPropInitialValue, }) => {
     const dotIndex = key.indexOf('.');
     if (dotIndex === -1) {
         const { attr: topLevelAttr } = findJsxAttribute(attributes, key);
         if (!topLevelAttr) {
+            if (missingPropInitialValue) {
+                return {
+                    expression: createMissingPropExpression(missingPropInitialValue),
+                    setExpression: (nextExpression) => {
+                        attributes.push(createJsxExpressionAttribute(key, nextExpression));
+                    },
+                };
+            }
             throw new Error(`Cannot update keyframes: "${key}" is not set`);
         }
         const expression = getExpressionFromJsxAttribute(topLevelAttr);
@@ -298,6 +374,18 @@ const getSequenceWritableProp = ({ attributes, key, }) => {
     const childKey = key.slice(dotIndex + 1);
     const { attr: parentAttr } = findJsxAttribute(attributes, parentKey);
     if (!parentAttr) {
+        if (missingPropInitialValue) {
+            return {
+                expression: createMissingPropExpression(missingPropInitialValue),
+                setExpression: (nextExpression) => {
+                    attributes.push(createObjectExpressionAttribute({
+                        parentKey,
+                        childKey,
+                        expression: nextExpression,
+                    }));
+                },
+            };
+        }
         throw new Error(`Cannot update keyframes: "${parentKey}" is not set`);
     }
     const objExpr = getObjectExpression(parentAttr);
@@ -306,6 +394,14 @@ const getSequenceWritableProp = ({ attributes, key, }) => {
     }
     const { prop } = findObjectProperty(objExpr, childKey);
     if (!prop) {
+        if (missingPropInitialValue) {
+            return {
+                expression: createMissingPropExpression(missingPropInitialValue),
+                setExpression: (nextExpression) => {
+                    objExpr.properties.push(createObjectProperty(childKey, nextExpression));
+                },
+            };
+        }
         throw new Error(`Cannot update keyframes: "${key}" is not set`);
     }
     return {
@@ -315,7 +411,7 @@ const getSequenceWritableProp = ({ attributes, key, }) => {
         },
     };
 };
-const updateSequenceKeyframesAst = ({ input, nodePath, updates, }) => {
+const updateSequenceKeyframesAst = ({ input, nodePath, updates, schema, }) => {
     var _a;
     var _b;
     const ast = (0, parse_ast_1.parseAst)(input);
@@ -335,11 +431,22 @@ const updateSequenceKeyframesAst = ({ input, nodePath, updates, }) => {
         const prop = getSequenceWritableProp({
             attributes: node.attributes,
             key: update.key,
+            missingPropInitialValue: update.operation.type === 'add'
+                ? {
+                    value: getInitialValueForMissingProp({
+                        schema: schema !== null && schema !== void 0 ? schema : null,
+                        key: update.key,
+                        newValue: update.operation.value,
+                    }),
+                }
+                : null,
         });
         oldValueStrings.push(recast.print(prop.expression).code);
         const { expression: nextExpression, introduced } = applyKeyframeOperation({
             expression: prop.expression,
+            key: update.key,
             operation: update.operation,
+            schema: schema !== null && schema !== void 0 ? schema : null,
         });
         newValueStrings.push(recast.print(nextExpression).code);
         prop.setExpression(nextExpression);
@@ -371,11 +478,12 @@ const updateSequenceKeyframesAst = ({ input, nodePath, updates, }) => {
     };
 };
 exports.updateSequenceKeyframesAst = updateSequenceKeyframesAst;
-const updateSequenceKeyframes = async ({ input, nodePath, updates, prettierConfigOverride, }) => {
+const updateSequenceKeyframes = async ({ input, nodePath, updates, schema, prettierConfigOverride, }) => {
     const { serialized, oldValueStrings, newValueStrings, logLine, updatedNodePath, } = (0, exports.updateSequenceKeyframesAst)({
         input,
         nodePath,
         updates,
+        schema,
     });
     const { output, formatted } = await (0, format_file_content_1.formatFileContent)({
         input: serialized,
@@ -391,7 +499,7 @@ const updateSequenceKeyframes = async ({ input, nodePath, updates, prettierConfi
     };
 };
 exports.updateSequenceKeyframes = updateSequenceKeyframes;
-const updateEffectKeyframesAst = ({ input, sequenceNodePath, effectIndex, updates, }) => {
+const updateEffectKeyframesAst = ({ input, sequenceNodePath, effectIndex, updates, schema, }) => {
     var _a, _b;
     var _c, _d, _e;
     const ast = (0, parse_ast_1.parseAst)(input);
@@ -426,7 +534,9 @@ const updateEffectKeyframesAst = ({ input, sequenceNodePath, effectIndex, update
         oldValueStrings.push(recast.print(prop.value).code);
         const { expression: nextExpression, introduced } = applyKeyframeOperation({
             expression: prop.value,
+            key: update.key,
             operation: update.operation,
+            schema: schema !== null && schema !== void 0 ? schema : null,
         });
         newValueStrings.push(recast.print(nextExpression).code);
         prop.value = nextExpression;
@@ -459,12 +569,13 @@ const updateEffectKeyframesAst = ({ input, sequenceNodePath, effectIndex, update
     };
 };
 exports.updateEffectKeyframesAst = updateEffectKeyframesAst;
-const updateEffectKeyframes = async ({ input, sequenceNodePath, effectIndex, updates, prettierConfigOverride, }) => {
+const updateEffectKeyframes = async ({ input, sequenceNodePath, effectIndex, updates, schema, prettierConfigOverride, }) => {
     const { serialized, oldValueStrings, newValueStrings, logLine, effectCallee, updatedSequenceNodePath, } = (0, exports.updateEffectKeyframesAst)({
         input,
         sequenceNodePath,
         effectIndex,
         updates,
+        schema,
     });
     const { output, formatted } = await (0, format_file_content_1.formatFileContent)({
         input: serialized,

package/dist/helpers/get-ast-node-path.js

@@ -35,9 +35,14 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAstNodePath = void 0;
 const recast = __importStar(require("recast"));
+const import_agnostic_node_path_1 = require("./import-agnostic-node-path");
 const getAstNodePath = (ast, nodePath) => {
+    const resolvedNodePath = (0, import_agnostic_node_path_1.fromImportAgnosticNodePath)({ ast, nodePath });
+    if (!resolvedNodePath) {
+        return null;
+    }
     let current = new recast.types.NodePath(ast);
-    for (const segment of nodePath) {
+    for (const segment of resolvedNodePath) {
         current = current.get(segment);
         if (current.value === null || current.value === undefined) {
             return null;

package/dist/helpers/import-agnostic-node-path.d.ts

@@ -0,0 +1,10 @@
+import type { File } from '@babel/types';
+import type { SequenceNodePath } from 'remotion';
+export declare const toImportAgnosticNodePath: ({ ast, nodePath, }: {
+    ast: File;
+    nodePath: SequenceNodePath;
+}) => SequenceNodePath;
+export declare const fromImportAgnosticNodePath: ({ ast, nodePath, }: {
+    ast: File;
+    nodePath: SequenceNodePath;
+}) => SequenceNodePath | null;

package/dist/helpers/import-agnostic-node-path.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromImportAgnosticNodePath = exports.toImportAgnosticNodePath = void 0;
+const getActualIndex = ({ items, agnosticIndex, shouldIgnore, context, }) => {
+    let seenIncludedNodes = 0;
+    for (let i = 0; i < items.length; i++) {
+        if (shouldIgnore(items[i], context)) {
+            continue;
+        }
+        if (seenIncludedNodes === agnosticIndex) {
+            return i;
+        }
+        seenIncludedNodes++;
+    }
+    return null;
+};
+const getAgnosticIndex = ({ items, actualIndex, shouldIgnore, context, }) => {
+    if (actualIndex < 0 || actualIndex >= items.length) {
+        return null;
+    }
+    let seenIncludedNodes = 0;
+    for (let i = 0; i <= actualIndex; i++) {
+        if (shouldIgnore(items[i], context)) {
+            continue;
+        }
+        if (i === actualIndex) {
+            return seenIncludedNodes;
+        }
+        seenIncludedNodes++;
+    }
+    return null;
+};
+const getUseCurrentFrameLocalNames = (ast) => {
+    var _a;
+    var _b;
+    const names = new Set(['useCurrentFrame']);
+    for (const statement of ast.program.body) {
+        if (statement.type !== 'ImportDeclaration' ||
+            statement.source.value !== 'remotion') {
+            continue;
+        }
+        for (const specifier of statement.specifiers) {
+            if (specifier.type === 'ImportSpecifier' &&
+                specifier.imported.type === 'Identifier' &&
+                specifier.imported.name === 'useCurrentFrame') {
+                names.add((_b = (_a = specifier.local) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : 'useCurrentFrame');
+            }
+        }
+    }
+    return names;
+};
+const isUseCurrentFrameCall = (node, useCurrentFrameLocalNames) => {
+    return ((node === null || node === void 0 ? void 0 : node.type) === 'CallExpression' &&
+        node.callee.type === 'Identifier' &&
+        useCurrentFrameLocalNames.has(node.callee.name));
+};
+const isUseCurrentFrameStatement = (node, useCurrentFrameLocalNames) => {
+    if (node.type === 'ExpressionStatement') {
+        return isUseCurrentFrameCall(node.expression, useCurrentFrameLocalNames);
+    }
+    if (node.type !== 'VariableDeclaration' || node.declarations.length !== 1) {
+        return false;
+    }
+    return isUseCurrentFrameCall(node.declarations[0].init, useCurrentFrameLocalNames);
+};
+const getIgnoredNodePredicate = (ast) => {
+    const useCurrentFrameLocalNames = getUseCurrentFrameLocalNames(ast);
+    return (node, { parent, property }) => {
+        if (parent.type === 'Program' &&
+            property === 'body' &&
+            node.type === 'ImportDeclaration') {
+            return true;
+        }
+        if (parent.type === 'BlockStatement' && property === 'body') {
+            return isUseCurrentFrameStatement(node, useCurrentFrameLocalNames);
+        }
+        return false;
+    };
+};
+const getChild = (value, segment) => {
+    var _a, _b;
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        return (_a = value[segment]) !== null && _a !== void 0 ? _a : null;
+    }
+    if (typeof value !== 'object') {
+        return null;
+    }
+    return (_b = value[segment]) !== null && _b !== void 0 ? _b : null;
+};
+const transformNodePathIndices = ({ ast, nodePath, direction, }) => {
+    const shouldIgnore = getIgnoredNodePredicate(ast);
+    const transformed = [];
+    let current = ast;
+    let arrayContext = null;
+    for (const segment of nodePath) {
+        if (typeof segment === 'string') {
+            const parent = current;
+            current = getChild(current, segment);
+            if (Array.isArray(current) &&
+                parent &&
+                typeof parent === 'object' &&
+                'type' in parent) {
+                arrayContext = { parent: parent, property: segment };
+            }
+            else {
+                arrayContext = null;
+            }
+            transformed.push(segment);
+            continue;
+        }
+        if (!Array.isArray(current) || !arrayContext) {
+            current = getChild(current, segment);
+            transformed.push(segment);
+            continue;
+        }
+        const mappedIndex = direction === 'to-agnostic'
+            ? getAgnosticIndex({
+                items: current,
+                actualIndex: segment,
+                shouldIgnore,
+                context: arrayContext,
+            })
+            : getActualIndex({
+                items: current,
+                agnosticIndex: segment,
+                shouldIgnore,
+                context: arrayContext,
+            });
+        if (mappedIndex === null) {
+            if (direction === 'from-agnostic') {
+                return null;
+            }
+            current = getChild(current, segment);
+            transformed.push(segment);
+            continue;
+        }
+        current = getChild(current, direction === 'to-agnostic' ? segment : mappedIndex);
+        arrayContext = null;
+        transformed.push(mappedIndex);
+    }
+    return transformed;
+};
+const toImportAgnosticNodePath = ({ ast, nodePath, }) => {
+    var _a;
+    return ((_a = transformNodePathIndices({ ast, nodePath, direction: 'to-agnostic' })) !== null && _a !== void 0 ? _a : nodePath);
+};
+exports.toImportAgnosticNodePath = toImportAgnosticNodePath;
+const fromImportAgnosticNodePath = ({ ast, nodePath, }) => {
+    return transformNodePathIndices({ ast, nodePath, direction: 'from-agnostic' });
+};
+exports.fromImportAgnosticNodePath = fromImportAgnosticNodePath;

package/dist/helpers/imports.d.ts

@@ -0,0 +1,16 @@
+import type { File, ImportDeclaration, ImportSpecifier } from '@babel/types';
+export declare const getImportedName: (specifier: ImportSpecifier) => string;
+export declare const findImportDeclaration: (ast: File, sourcePath: string) => ImportDeclaration | null;
+export declare const insertImportDeclaration: (ast: File, importDeclaration: ImportDeclaration) => void;
+export declare const normalizeImportSpacing: (input: string) => string;
+export declare const ensureNamedImport: ({ ast, importedName, sourcePath, localName, }: {
+    ast: File;
+    importedName: string;
+    sourcePath: string;
+    localName: string;
+}) => string;
+export declare const ensureNamedImports: ({ ast, importedNames, sourcePath, }: {
+    ast: File;
+    importedNames: ReadonlySet<string>;
+    sourcePath: string;
+}) => void;

package/dist/helpers/imports.js

@@ -0,0 +1,145 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureNamedImports = exports.ensureNamedImport = exports.normalizeImportSpacing = exports.insertImportDeclaration = exports.findImportDeclaration = exports.getImportedName = void 0;
+const recast = __importStar(require("recast"));
+const b = recast.types.builders;
+const getImportedName = (specifier) => {
+    if (specifier.imported.type === 'Identifier') {
+        return specifier.imported.name;
+    }
+    return specifier.imported.value;
+};
+exports.getImportedName = getImportedName;
+const findImportDeclaration = (ast, sourcePath) => {
+    for (const stmt of ast.program.body) {
+        if (stmt.type === 'ImportDeclaration' &&
+            stmt.source.type === 'StringLiteral' &&
+            stmt.source.value === sourcePath) {
+            return stmt;
+        }
+    }
+    return null;
+};
+exports.findImportDeclaration = findImportDeclaration;
+const findImportDeclarations = (ast, sourcePath) => {
+    return ast.program.body.filter((stmt) => stmt.type === 'ImportDeclaration' &&
+        stmt.source.type === 'StringLiteral' &&
+        stmt.source.value === sourcePath);
+};
+const insertImportDeclaration = (ast, importDeclaration) => {
+    const { body } = ast.program;
+    let lastImportIndex = -1;
+    for (let i = 0; i < body.length; i++) {
+        if (body[i].type === 'ImportDeclaration') {
+            lastImportIndex = i;
+        }
+    }
+    body.splice(lastImportIndex + 1, 0, importDeclaration);
+};
+exports.insertImportDeclaration = insertImportDeclaration;
+const normalizeImportSpacing = (input) => {
+    return input.replace(/(import[^\n]*\n)\n+(?=import\b)/g, '$1');
+};
+exports.normalizeImportSpacing = normalizeImportSpacing;
+const hasNamespaceSpecifier = (importDeclaration) => {
+    var _a;
+    return (_a = importDeclaration.specifiers) === null || _a === void 0 ? void 0 : _a.some((specifier) => specifier.type === 'ImportNamespaceSpecifier');
+};
+const ensureNamedImport = ({ ast, importedName, sourcePath, localName, }) => {
+    var _a, _b;
+    var _c, _d;
+    const existingImports = findImportDeclarations(ast, sourcePath);
+    for (const existingImportDeclaration of existingImports) {
+        const matchingSpecifier = (_a = existingImportDeclaration.specifiers) === null || _a === void 0 ? void 0 : _a.find((importSpecifierCandidate) => importSpecifierCandidate.type === 'ImportSpecifier' &&
+            (0, exports.getImportedName)(importSpecifierCandidate) === importedName);
+        if (matchingSpecifier) {
+            return (_c = (_b = matchingSpecifier.local) === null || _b === void 0 ? void 0 : _b.name) !== null && _c !== void 0 ? _c : importedName;
+        }
+    }
+    const existingImport = existingImports.find((candidateImportDeclaration) => !hasNamespaceSpecifier(candidateImportDeclaration));
+    if (existingImport) {
+        const importSpecifier = b.importSpecifier(b.identifier(importedName), localName === importedName ? null : b.identifier(localName));
+        existingImport.specifiers = [
+            ...((_d = existingImport.specifiers) !== null && _d !== void 0 ? _d : []),
+            importSpecifier,
+        ];
+        return localName;
+    }
+    const specifier = b.importSpecifier(b.identifier(importedName), localName === importedName ? null : b.identifier(localName));
+    const importDeclaration = b.importDeclaration([specifier], b.stringLiteral(sourcePath));
+    (0, exports.insertImportDeclaration)(ast, importDeclaration);
+    return localName;
+};
+exports.ensureNamedImport = ensureNamedImport;
+const ensureNamedImports = ({ ast, importedNames, sourcePath, }) => {
+    var _a, _b;
+    if (importedNames.size === 0) {
+        return;
+    }
+    const existingImports = findImportDeclarations(ast, sourcePath);
+    const existingNames = new Set();
+    for (const existingImportDeclaration of existingImports) {
+        for (const importSpecifierCandidate of (_a = existingImportDeclaration.specifiers) !== null && _a !== void 0 ? _a : []) {
+            if (importSpecifierCandidate.type !== 'ImportSpecifier') {
+                continue;
+            }
+            existingNames.add((0, exports.getImportedName)(importSpecifierCandidate));
+        }
+    }
+    const existingImport = existingImports.find((candidateImportDeclaration) => !hasNamespaceSpecifier(candidateImportDeclaration));
+    if (existingImport) {
+        for (const importedName of importedNames) {
+            if (existingNames.has(importedName)) {
+                continue;
+            }
+            existingImport.specifiers = [
+                ...((_b = existingImport.specifiers) !== null && _b !== void 0 ? _b : []),
+                b.importSpecifier(b.identifier(importedName)),
+            ];
+            existingNames.add(importedName);
+        }
+        return;
+    }
+    const specifiers = [...importedNames]
+        .filter((importedName) => !existingNames.has(importedName))
+        .map((importedName) => b.importSpecifier(b.identifier(importedName)));
+    if (specifiers.length === 0) {
+        return;
+    }
+    const importDeclaration = b.importDeclaration(specifiers, b.stringLiteral(sourcePath));
+    (0, exports.insertImportDeclaration)(ast, importDeclaration);
+};
+exports.ensureNamedImports = ensureNamedImports;