Hi @Paul_St_George I have never done this exact thing before, but I've made an attempt that I think may be useful, although due to some surprising complications, the script is a bit more complicated than I would have expected.
Are you a scripter? If so, you can follow the code to see what's going on, but you will see some strangeness. For example, to export a single path item as SVG, the way I got this to work was by deleting all the other items, temporarily, prior to the export. You will see that I only use item's UUIDs to access DOM references—this is for two reasons: (1) the references were broken by the use of app.undo(), even though I would have thought that the items were still valid, and (2) Illustrator crashed a lot when I tried simpler approaches.
In the end I think I've come up with a robust script—but I'm also sure there are going to be plenty of bugs, so let me know what happens if you end up using it, or parts of it.
You can edit the `setttings` object as you like. For example, try turning off `enforceArtboardBounds`.
- Mark
/**
* @file Export Selected PathItems As SVG.js
*
* Demonstration script:
* - Exports every selected path item and compound path item
* on the active artboard as separate SVG file.
* - Exported files will be named by their item name
* or item typename and uuid.
*
* @author m1b
* @version 2025-05-25
* @discussion https://community.adobe.com/t5/illustrator-discussions/how-to-export-multiple-svg-from-one-layer/m-p/15338630
*/
(function () {
var doc = app.activeDocument;
var settings = {
// whether to export an unpainted rectangle to enforce the SVG viewBox
enforceArtboardBounds: true,
// where to export to
exportFolderPath: '#DOCUMENT_FOLDER#/SVG',
// the SVG export options to use
exportOptions: {
coordinatePrecision: 1,
cssProperties: SVGCSSPropertyLocation.STYLEATTRIBUTES,
fontType: SVGFontType.OUTLINEFONT,
rasterImageLocation: RasterImageLocation.EMBED,
svgId: SVGIdType.SVGIDREGULAR,
svgMinify: false,
svgResponsive: true,
},
// these are the things to export, choose `doc.pageItems` to export every item
targetItems: doc.selection,
// whether to show the results dialog afterwards
showResult: true,
};
if (!doc.fullName.exists)
return alert('Please save this document first.');
if (0 === settings.targetItems.length)
return alert('Please select some path items to export and try again.');
var counter = 0;
// collect the selection, so we can restore it later
var selectedUUIDs = [];
for (var i = 0; i < doc.selection.length; i++)
selectedUUIDs.push(doc.selection[i].uuid);
// uuids of every page item
var allItemUUIDs = [];
// uuids of the items to export
var targetItemUUIDs = [];
// arrays to record whether an item has been processed
var allAlreadyDone = [],
targetAlreadyDone = [];
// in this loop we collect UUIDs for the things do and don't want to export
for (var i = 0, item; i < doc.pageItems.length; i++) {
item = doc.pageItems[i];
if ('CompoundPathItem' === item.parent.constructor.name)
// we don't want a mere path of a compound path item
item = item.parent;
if (allAlreadyDone[item.uuid])
// already got this one
continue;
// store uuid for later
allItemUUIDs.push(item.uuid);
allAlreadyDone[item.uuid] = true;
if (
'PathItem' !== item.constructor.name
&& 'CompoundPathItem' !== item.constructor.name
)
// not a path item or compound path item
continue;
if (-1 === indexOfArray(settings.targetItems, item))
// not a target item to export
continue;
if (targetAlreadyDone[item.uuid])
// already got this one
continue;
// store item for later
targetItemUUIDs.push(item.uuid);
// mark as done
targetAlreadyDone[item.uuid] = true;
}
// prepare the layers
var layerStatus = [];
for (var i = 0; i < doc.layers.length; i++) {
layerStatus[i] = {
locked: doc.layers[i].locked,
visible: doc.layers[i].visible,
};
doc.layers[i].locked = false;
doc.layers[i].visible = true;
}
// add an undo level here so this work doesn't get undone later
app.redraw();
// get the exporter function
var exportArtboard = getSVGExporter(doc, settings.exportFolderPath, settings.exportOptions, settings.enforceArtboardBounds);
// this loop is where we do the exporting
for (var i = 0, item, itemUUID; i < targetItemUUIDs.length; i++) {
itemUUID = targetItemUUIDs[i];
item = getThing(doc.pageItems, 'uuid', itemUUID)
// remove all the items we don't want to export
for (var j = allItemUUIDs.length - 1; j >= 0; j--)
if (allItemUUIDs[j] !== itemUUID)
getThing(doc.pageItems, 'uuid', allItemUUIDs[j]).remove();
// establish the artboard index for this item
var artboardIndex = getArtboardIndexOfItem(item, doc.artboards);
if (undefined == artboardIndex)
continue;
// export with its uuid as filename
exportArtboard(artboardIndex, item.name || item.typename + '-' + itemUUID);
counter++;
// bring everything back for the next go
app.undo();
}
// reinstate the selection
var selection = [];
for (var i = 0; i < selectedUUIDs.length; i++)
selection.push(getThing(doc.pageItems, 'uuid', selectedUUIDs[i]));
doc.selection = selection;
// restore the layers' properties
for (var i = 0; i < doc.layers.length; i++) {
doc.layers[i].locked = layerStatus[i].locked;
doc.layers[i].visible = layerStatus[i].visible;
}
if (settings.showResult)
// show result
alert('Exported ' + counter + ' path items as SVG.');
// reveal the exported files
doc.fullName.parent.execute();
})();
/**
* Returns a pre-configured exporter function.
* @author m1b
* @version 2025-05-25
* @param {Document} doc - an Illustrator Document.
* @param {String} [exportFolderPath] - the export folder path (default: SVG folder in document's folder).
* @param {Object} [properties] - the export options properties to set (default: none, use default values).
* @param {Boolean} [enforceArtboardBounds] - whether to force the svg viewBox to match the artboard bounds (default: false).,
*/
function getSVGExporter(doc, exportFolderPath, properties, enforceArtboardBounds) {
properties = properties || {};
if (!exportFolderPath)
exportFolderPath = '#DOCUMENT_FOLDER#/SVG';
// replace placeholders in export folder path
exportFolderPath = exportFolderPath
.replace('#DOCUMENT_FOLDER#', String(doc.fullName.parent));
var exportFolder = Folder(exportFolderPath);
if (!exportFolder.exists)
exportFolder.create();
// set up the SVG export options
var exportOptions = new ExportOptionsWebOptimizedSVG();
// apply export options properties
for (var key in properties)
if (properties.hasOwnProperty(key))
exportOptions[key] = properties[key];
return exportArtboardAsSVG;
/**
* Exports an artboard as SVG into the same folder as `doc`.
* @author m1b
* @version 2025-05-25
* @param {Number} artboardIndex - the artboard index (zero based).
* @param {String} fileName - the filename for the exported file (do not include file extension).
*/
function exportArtboardAsSVG(artboardIndex, fileName) {
artboardIndex = Math.min(artboardIndex, doc.artboards.length - 1);
// draw this to force the svg viewBox to match the artboard bounds
var tempRectangle = enforceArtboardBounds
? drawRectangle(doc, doc.artboards[artboardIndex].artboardRect, undefined, doc, { filled: false, stroked: false })
: undefined;
// set artboard range
doc.artboards.setActiveArtboardIndex(artboardIndex);
exportOptions.artboardRange = artboardIndex + 1;
var file = File(exportFolder + '/' + fileName + '.svg');
doc.exportFile(file, ExportType.WOSVG, exportOptions);
if (tempRectangle)
tempRectangle.remove();
};
};
/**
* Returns a thing with matching property.
* If `key` is undefined, evaluate the object itself.
* @author m1b
* @version 2024-04-21
* @param {Array|Collection} things - the things to look through.
* @param {String} [key] - the property name (default: undefined).
* @param {*} value - the value to match.
* @returns {*?} - the thing, if found.
*/
function getThing(things, key, value) {
for (var i = 0, obj; i < things.length; i++)
if ((undefined == key ? things[i] : things[i][key]) == value)
return things[i];
};
/**
* Returns index of `obj` within `array`,
* or -1 if `obj` is not found.
* @param {Array<*>} array - the array to search in.
* @param {*} obj - the object to look for.
* @returns {Number}
*/
function indexOfArray(array, obj) {
for (var i = 0; i < array.length; i++)
if (array[i] == obj)
return i;
return -1;
};
/**
* Draws a rectangle in the container.
* Takes Large Scale Documents into account.
* @author m1b
* @version 2024-09-26
* @param {Document} doc - an Illustrator document.
* @param {Array<Number>} rect - the rectangle dimensions [left, top, width, height].
* @param {Number} [unitFactor] - eg. 72 to convert to inches. All values will be scaled by this (default: 1).
* @param {Document|Layer|GroupItem} container - an Illustrator page item container (default: doc).
* @param {Object} [props] - properties to assign to the rectangle (default: none).
* @return {PathItem}
*/
function drawRectangle(doc, rect, unitFactor, container, properties) {
properties = properties || {};
unitFactor = unitFactor || 1;
container = container || doc;
var sf = 1 / doc.scaleFactor * unitFactor;
var rectangle = container.pathItems.rectangle(rect[1] * -sf, rect[0] * sf, (rect[2] - rect[0]) * sf, (rect[3] - rect[1]) * -sf); // T,L,W,H
// defaults
rectangle.filled = true;
rectangle.stroked = false;
// apply properties
for (var key in properties)
if (properties.hasOwnProperty(key))
rectangle[key] = properties[key];
return rectangle;
};
/**
* Returns the index of the artboard that has most overlap the item's bounds.
* @author m1b
* @version 2025-05-25
* @param {PageItem} item - a page item.
* @param {Array<Artboard>} artboards - artboards to search, if undefined, search all.
* @param {Boolean} preferIndex - if true, returns array of artboard indices {Array[Number]}
* @returns {Number?} - the artboard index;
*/
function getArtboardIndexOfItem(item, artboards) {
var artboardIndex;
for (var i = 0, overlap, maxOverlap = 0; i < artboards.length; i++) {
overlap = getOverlapArea(item.geometricBounds, artboards[i].artboardRect);
if (!overlap)
continue;
if (overlap > maxOverlap) {
maxOverlap = overlap;
artboardIndex = i;
}
}
if (undefined !== artboardIndex)
return artboardIndex;
};
/**
* Returns the overlapping area between
* two rectangular bounds.
* @author m1b
* @version 2025-05-25
* @param {bounds} a - First bounds [L, T, R, B].
* @param {bounds} b - Second bounds [L, T, R, B].
* @returns {Number|null} - area of overlap, or null if no overlap.
*/
function getOverlapArea(a, b) {
var left = Math.max(a[0], b[0]),
top = Math.min(a[1], b[1]),
right = Math.min(a[2], b[2]),
bottom = Math.max(a[3], b[3]);
var width = right - left,
height = top - bottom;
if (
width > 0
&& height > 0
)
return width * height;
// No overlap
return null;
};
Edit 2025-05-25: added check for locked or hidden layers.
Edit 2025-05-25: fixed bug where selection was not restored when `settings.targetItems` is set to `doc.pageItems`, ie. to export every path item in document.
1 Correct answer
4
Replies
AdChoices