weapp-tailwindcss
Version:
把 tailwindcss 原子化样式思想，带给小程序开发者们! bring tailwindcss to miniprogram developers!
690 lines (689 loc) • 29.2 kB
JavaScript
const require_rolldown_runtime = require("./rolldown-runtime-CVvi-lCc.cjs");
const require_generator = require("./generator-BE34PYSC.cjs");
const require_options = require("./options-hVsoTfwL.cjs");
const require_v4_generation_core = require("./v4-generation-core-CDI6ChiH.cjs");
const require_wxml = require("./wxml-DSMNuUaP.cjs");
const require_hmr_timing = require("./hmr-timing-Cye_A4mI.cjs");
const require_context = require("./context-OqD_eBxQ.cjs");
const require_tailwindcss = require("./tailwindcss-DcpiKvmJ.cjs");
const require_style_options = require("./style-options-B_ppaVIg.cjs");
let node_fs = require("node:fs");
node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
let node_path = require("node:path");
node_path = require_rolldown_runtime.__toESM(node_path, 1);
let node_process = require("node:process");
node_process = require_rolldown_runtime.__toESM(node_process, 1);
let node_buffer = require("node:buffer");
let node_stream = require("node:stream");
node_stream = require_rolldown_runtime.__toESM(node_stream, 1);
let _weapp_tailwindcss_postcss = require("@weapp-tailwindcss/postcss");
//#region src/bundlers/gulp/module-graph.ts
const MODULE_EXTENSIONS = [
".js",
".mjs",
".cjs",
".ts",
".tsx",
".jsx"
];
function resolveWithExtensions(base) {
for (const ext of MODULE_EXTENSIONS) {
const candidate = `${base}${ext}`;
try {
if (node_fs.default.statSync(candidate).isFile()) return candidate;
} catch {
continue;
}
}
}
function resolveLocalModuleCandidate(base) {
try {
const stat = node_fs.default.statSync(base);
if (stat.isFile()) return base;
if (stat.isDirectory()) {
const resolvedIndex = resolveWithExtensions(node_path.default.join(base, "index"));
if (resolvedIndex) return resolvedIndex;
}
} catch {}
if (!node_path.default.extname(base)) return resolveWithExtensions(base);
}
function createGulpModuleGraphOptions(opts) {
return {
resolve(specifier, importer) {
if (!specifier) return;
if (!specifier.startsWith(".") && !node_path.default.isAbsolute(specifier)) return;
return resolveLocalModuleCandidate(node_path.default.resolve(node_path.default.dirname(importer), specifier));
},
load(id) {
try {
return node_fs.default.readFileSync(id, "utf8");
} catch {
return;
}
},
filter(id) {
const relative = node_path.default.relative(node_process.default.cwd(), id);
return opts.jsMatcher?.(relative) === true || opts.wxsMatcher?.(relative) === true;
}
};
}
//#endregion
//#region src/bundlers/gulp/runtime-snapshot.ts
function createGulpRuntimeSnapshot(runtimeSourcesByFile, state, computeHash, options = {}) {
return require_hmr_timing.buildRuntimeCompilationSnapshot([...runtimeSourcesByFile.entries()].map(([file, entry]) => ({
file,
runtimeCandidate: true,
source: entry.source,
type: entry.type
})), state, {
computeHash,
createRuntimeAffectingSignature: require_v4_generation_core.createRuntimeAffectingSourceSignature,
removedFiles: options.removedFiles
});
}
//#endregion
//#region src/bundlers/gulp/shared/create-native-framework-plugins/cache-state.ts
const GULP_RUNTIME_SOURCE_CACHE_MAX = 256;
const GULP_PROCESS_CACHE_MAX = 512;
function toMb(bytes) {
return Math.round(bytes / 1024 / 1024);
}
function touchMapEntry(map, key, value) {
map.delete(key);
map.set(key, value);
}
function pruneGulpRuntimeSourceCaches(sourcesByFile) {
const removedFiles = [];
while (sourcesByFile.size > GULP_RUNTIME_SOURCE_CACHE_MAX) {
const oldestKey = sourcesByFile.keys().next().value;
if (typeof oldestKey !== "string") break;
sourcesByFile.delete(oldestKey);
removedFiles.push(oldestKey);
}
return removedFiles;
}
function rememberGulpProcessCacheKey(cacheKeys, key) {
cacheKeys.delete(key);
cacheKeys.add(key);
while (cacheKeys.size > GULP_PROCESS_CACHE_MAX) {
const oldestKey = cacheKeys.keys().next().value;
if (typeof oldestKey !== "string") break;
cacheKeys.delete(oldestKey);
}
}
function pruneGulpProcessCache(cache, cacheKeys) {
cache.prune?.({
cacheKeys,
hashKeys: cacheKeys
});
}
function resolveGulpMemoryDebugStats(context) {
if (node_process.default.env["WEAPP_TW_HMR_MEMORY_DEBUG"] !== "1") return;
const memory = node_process.default.memoryUsage();
return {
phase: context.phase,
process: {
rssMb: toMb(memory.rss),
heapTotalMb: toMb(memory.heapTotal),
heapUsedMb: toMb(memory.heapUsed),
externalMb: toMb(memory.external),
arrayBuffersMb: toMb(memory.arrayBuffers)
},
runtime: {
runtimeSet: context.runtimeSet.size,
runtimeSourceHashByFile: context.runtimeSourceHashByFile.size,
runtimeSourcesByFile: context.runtimeSourcesByFile.size,
maxRuntimeSources: GULP_RUNTIME_SOURCE_CACHE_MAX
},
processCache: {
instance: context.cache.instance.size,
hashMap: context.cache.hashMap.size,
activeCacheKeys: context.gulpProcessCacheKeys.size,
maxCacheKeys: GULP_PROCESS_CACHE_MAX
},
gulpOptions: { defaultStyleHandlerOptions: context.defaultStyleHandlerOptionsCache.size },
tailwind: { v4: require_generator.getTailwindV4IncrementalGenerateCacheStats() }
};
}
//#endregion
//#region src/bundlers/gulp/asset-emission-plan.ts
function applyGulpAssetEmissionPlan(plan, options) {
for (const operation of plan.operations()) {
if (operation.kind === "delete") {
options.deleteAsset(operation.assetId);
continue;
}
options.writeAsset(operation.assetId, typeof operation.source === "string" ? node_buffer.Buffer.from(operation.source) : node_buffer.Buffer.from(operation.source));
}
}
function writeGulpFileAsset(file, source) {
const plan = new require_v4_generation_core.AssetEmissionPlan();
plan.write(file.path, source);
applyGulpAssetEmissionPlan(plan, {
deleteAsset(assetId) {
if (assetId === file.path) file.contents = null;
},
writeAsset(assetId, contents) {
if (assetId === file.path) file.contents = contents;
}
});
}
//#endregion
//#region src/bundlers/gulp/vinyl-transform.ts
const Transform = node_stream.default.Transform;
function createVinylTransform(phase, handler, getTimingDetails) {
return new Transform({
objectMode: true,
async transform(file, _encoding, callback) {
const hmrTimingStartedAt = performance.now();
try {
await handler(file);
require_hmr_timing.emitHmrTiming("gulp", phase, performance.now() - hmrTimingStartedAt, {
file: file.relative || node_path.default.basename(file.path),
...getTimingDetails?.(file)
});
callback(null, file);
} catch (error) {
callback(error, file);
}
}
});
}
//#endregion
//#region src/bundlers/gulp/shared/create-native-framework-plugins/file-transforms.ts
function createGulpFileTransforms(context) {
const { cache, createRuntimeSetHash, debug, generatedCssPreflightModeByFile, getCompilationDependencyRevision, getSourceCandidateGetter, getSourceCandidateSourceGetter, getRuntimeSet, gulpProcessCacheKeys, opts, refreshGulpV4SourceCandidates, refreshRuntimeSet, refreshRuntimeSetForSource, registerAutoCssSource, rememberCompilationScope, resolveGulpStyleOutputExtension, resolveGulpTransformTimingDetails, resolveModuleGraphOptions, resolveWxmlHandlerOptions, resolveWxssFileHandlerOptions, resolveWxssUserHandlerOptions, runtimeState } = context;
const { templateHandler, styleHandler, jsHandler } = opts;
function createWxssTransform(options, stage) {
return createVinylTransform(`css:${stage}`, async (file) => {
if (!file.contents) return;
const rawSource = file.contents.toString();
const cssSourceChanged = await registerAutoCssSource(file, rawSource);
const shouldUseGenerator = runtimeState.tailwindRuntime.majorVersion === 4;
let gulpSourceCandidateGetter = getSourceCandidateGetter();
if (shouldUseGenerator) gulpSourceCandidateGetter = await refreshGulpV4SourceCandidates(cssSourceChanged);
const nextRuntimeSet = await refreshRuntimeSet({
forceRefresh: cssSourceChanged,
forceCollect: cssSourceChanged,
clearCache: cssSourceChanged
});
const sourceCandidateSourceGetter = getSourceCandidateSourceGetter();
const sourceTraceTokenSources = sourceCandidateSourceGetter ? require_v4_generation_core.createCssTokenSourceMap(sourceCandidateSourceGetter(void 0), opts) : void 0;
const sourceTraceSignature = require_v4_generation_core.createCssSourceTraceCacheSignature(sourceTraceTokenSources, opts);
const sourceCandidateSignature = gulpSourceCandidateGetter ? `gulp-source-candidates:1:${[...gulpSourceCandidateGetter(void 0)].sort().join("\n")}` : void 0;
const styleOutputExtension = resolveGulpStyleOutputExtension(file);
const cssHandlerOptions = resolveWxssFileHandlerOptions(file, rawSource, options);
const outputFile = (file.relative || node_path.default.basename(file.path)).replaceAll(node_path.default.sep, "/");
const compilationScope = {
id: outputFile,
kind: cssHandlerOptions.isMainChunk ? "global" : "component"
};
rememberCompilationScope(file.path, compilationScope.id);
const compilationDependencyRevision = getCompilationDependencyRevision(compilationScope.id);
const outputSignature = `${styleOutputExtension ? `gulp-output:1:${stage}:${styleOutputExtension}` : `gulp-output:0:${stage}`}:compiler-dependencies:${compilationDependencyRevision}`;
await require_hmr_timing.processCachedTask({
cache,
cacheKey: file.path,
hash: createRuntimeSetHash(rawSource, nextRuntimeSet, sourceTraceSignature, sourceCandidateSignature, outputSignature),
applyResult(source) {
writeGulpFileAsset(file, source);
},
onCacheHit() {
debug("css cache hit: %s", file.path);
},
async transform() {
await runtimeState.readyPromise;
const generated = shouldUseGenerator ? await require_v4_generation_core.generateTailwindV4Css({
opts,
runtimeState,
runtime: nextRuntimeSet,
rawSource,
file: file.path,
outputFile,
scope: compilationScope,
cssHandlerOptions,
cssUserHandlerOptions: resolveWxssUserHandlerOptions(options),
getSourceCandidatesForEntries: gulpSourceCandidateGetter,
styleHandler,
debug,
deferCssAdaptation: stage === "generate"
}) : void 0;
const transformedCss = generated?.css ?? (stage === "generate" ? rawSource : (await styleHandler(rawSource, cssHandlerOptions)).css);
if (stage === "generate") {
const preflightMode = generated?.metadata?.preflightMode;
if (preflightMode) generatedCssPreflightModeByFile.set(file.path, preflightMode);
else generatedCssPreflightModeByFile.delete(file.path);
}
const css = require_v4_generation_core.annotateCssSourceTrace(transformedCss, {
opts,
tokenSources: sourceTraceTokenSources
});
const generatedCss = stage === "generate" && generated ? `${require_v4_generation_core.createBundlerGeneratedCssMarker("gulp", file.path)}\n${css}` : css;
const outputCss = stage === "generate" ? generatedCss : (0, _weapp_tailwindcss_postcss.rewriteLocalCssImportRequestsForOutput)(generatedCss, { styleOutputExtension });
debug("css handle: %s", file.path);
return { result: outputCss };
}
});
rememberGulpProcessCacheKey(gulpProcessCacheKeys, file.path);
pruneGulpProcessCache(cache, gulpProcessCacheKeys);
}, () => resolveGulpTransformTimingDetails(`css:${stage}`));
}
const generateWxss = (options = {}) => createWxssTransform(options, "generate");
const transformWxss = (options = {}) => createWxssTransform(options, "transform");
const adaptWxss = (options = {}) => createVinylTransform("css:adapt", async (file) => {
if (!file.contents) return;
const rawSource = file.contents.toString();
const generatedCss = require_v4_generation_core.hasBundlerGeneratedCssMarker(rawSource);
const source = generatedCss ? require_v4_generation_core.stripBundlerGeneratedCssMarkers(rawSource) : rawSource;
const styleOutputExtension = resolveGulpStyleOutputExtension(file);
const cssHandlerOptions = resolveWxssFileHandlerOptions(file, source, options);
const handled = await styleHandler(source, cssHandlerOptions);
const preflightMode = generatedCssPreflightModeByFile.get(file.path);
writeGulpFileAsset(file, (0, _weapp_tailwindcss_postcss.rewriteLocalCssImportRequestsForOutput)(generatedCss ? require_v4_generation_core.finalizeMiniProgramGeneratorCss(handled.css, "weapp", runtimeState.tailwindRuntime.majorVersion, opts.cssPreflight, {
injectPreflight: preflightMode?.inject ?? cssHandlerOptions.isMainChunk,
preservePreflight: preflightMode?.preserve ?? cssHandlerOptions.isMainChunk,
styleOptions: cssHandlerOptions
}) : handled.css, { styleOutputExtension }));
debug("css adapt: %s", file.path);
}, () => resolveGulpTransformTimingDetails("css:adapt"));
const transformJs = (options = {}) => createVinylTransform("js", async (file) => {
if (!file.contents) return;
const filename = node_path.default.resolve(file.path);
const rawSource = file.contents.toString();
await refreshRuntimeSetForSource(file, rawSource, "js");
await runtimeState.readyPromise;
const moduleGraph = resolveModuleGraphOptions(options.moduleGraph);
const handlerOptions = {
...options,
generateMap: false,
filename,
moduleGraph,
babelParserOptions: {
...options?.babelParserOptions ?? {},
sourceFilename: filename
}
};
if (runtimeState.tailwindRuntime.majorVersion !== void 0) handlerOptions.tailwindcssMajorVersion = runtimeState.tailwindRuntime.majorVersion;
await require_hmr_timing.processCachedTask({
cache,
cacheKey: file.path,
rawSource,
applyResult(source) {
writeGulpFileAsset(file, source);
},
onCacheHit() {
debug("js cache hit: %s", file.path);
},
async transform() {
await runtimeState.readyPromise;
const currentSource = file.contents?.toString() ?? rawSource;
if (require_context.shouldSkipJsTransform(currentSource, {
...handlerOptions,
classNameSet: getRuntimeSet()
})) return { result: currentSource };
const { code } = await jsHandler(currentSource, getRuntimeSet(), handlerOptions);
debug("js handle: %s", file.path);
return { result: code };
}
});
rememberGulpProcessCacheKey(gulpProcessCacheKeys, file.path);
pruneGulpProcessCache(cache, gulpProcessCacheKeys);
}, () => resolveGulpTransformTimingDetails("js"));
const transformWxml = (options = {}) => createVinylTransform("html", async (file) => {
if (!file.contents) return;
const rawSource = file.contents.toString();
await refreshRuntimeSetForSource(file, rawSource, "html");
await runtimeState.readyPromise;
await require_hmr_timing.processCachedTask({
cache,
cacheKey: file.path,
rawSource,
applyResult(source) {
writeGulpFileAsset(file, source);
},
onCacheHit() {
debug("html cache hit: %s", file.path);
},
async transform() {
await runtimeState.readyPromise;
const code = await templateHandler(rawSource, resolveWxmlHandlerOptions(options));
debug("html handle: %s", file.path);
return { result: code };
}
});
rememberGulpProcessCacheKey(gulpProcessCacheKeys, file.path);
pruneGulpProcessCache(cache, gulpProcessCacheKeys);
}, () => resolveGulpTransformTimingDetails("html"));
return {
adaptWxss,
generateWxss,
transformWxss,
transformWxml,
transformJs
};
}
//#endregion
//#region src/bundlers/gulp/shared/create-native-framework-plugins.ts
const debug = require_wxml.createDebug();
const GULP_COMPILATION_SCOPE_CACHE_MAX = 512;
/**
* @name weapp-tw-gulp
* @description native framework 的插件组合实现
* @link https://tw.icebreaker.top/docs/quick-start/frameworks/native
*/
function createNativeGulpPlugins(options = {}) {
const hasInitialTailwindCssRoots = require_generator.hasConfiguredTailwindV4CssRoots(options);
const opts = require_context.getCompilerContext({
...options,
__internalDeferMissingCssEntriesWarning: true
});
const { cache } = opts;
const initialTailwindRuntime = opts.tailwindRuntime;
const refreshTailwindcssRuntime = opts.refreshTailwindcssRuntime;
const readyPromise = require_context.createTailwindRuntimeReadyPromise(initialTailwindRuntime);
let runtimeSet = /* @__PURE__ */ new Set();
const runtimeState = {
tailwindRuntime: initialTailwindRuntime,
readyPromise,
refreshTailwindcssRuntime
};
const defaultStyleHandlerOptionsCache = /* @__PURE__ */ new Map();
let cachedDefaultTemplateHandlerOptions;
let cachedDefaultTemplateRuntimeSet;
let cachedDefaultModuleGraphOptions;
let cachedGulpSourceCandidateGetter;
let cachedGulpSourceCandidateSourceGetter;
let runtimeSetInitialized = false;
let runtimeSetDirty = false;
const runtimeSourcesByFile = /* @__PURE__ */ new Map();
const runtimeSnapshotState = require_hmr_timing.createRuntimeCompilationBuildState();
const generatedCssPreflightModeByFile = /* @__PURE__ */ new Map();
const compilationScopeBySourceFile = /* @__PURE__ */ new Map();
let cachedGulpSourceCandidateSignature;
const gulpProcessCacheKeys = /* @__PURE__ */ new Set();
const bundleRuntimeClassSetManager = options.__internalGulpRuntimeClassSetManager ?? require_hmr_timing.createRuntimeClassSetManager();
function invalidateGulpSourceCandidates() {
cachedGulpSourceCandidateSignature = void 0;
cachedGulpSourceCandidateGetter = void 0;
cachedGulpSourceCandidateSourceGetter = void 0;
}
async function refreshRuntimeSet(options = false) {
const normalizedOptions = typeof options === "boolean" ? {
forceRefresh: options,
forceCollect: options,
clearCache: options
} : options;
const forceRefresh = normalizedOptions.forceRefresh === true;
const shouldForceCollect = normalizedOptions.forceCollect === true || runtimeSetDirty;
const clearCache = normalizedOptions.clearCache === true || runtimeSetDirty;
if (!forceRefresh && !shouldForceCollect && runtimeSetInitialized) return runtimeSet;
runtimeSet = await require_context.ensureRuntimeClassSet(runtimeState, {
forceRefresh,
forceCollect: shouldForceCollect,
clearCache,
allowEmpty: false
});
runtimeSetInitialized = true;
runtimeSetDirty = false;
return runtimeSet;
}
async function refreshRuntimeSetForSource(file, rawSource, type) {
const filename = node_path.default.resolve(file.path);
touchMapEntry(runtimeSourcesByFile, filename, {
source: rawSource,
type
});
require_hmr_timing.removeRuntimeCompilationBuildStateFiles(runtimeSnapshotState, pruneGulpRuntimeSourceCaches(runtimeSourcesByFile));
const snapshot = createGulpRuntimeSnapshot(runtimeSourcesByFile, runtimeSnapshotState, (source) => cache.computeHash(source));
const changed = snapshot.changedByType[type].has(filename);
require_hmr_timing.updateRuntimeCompilationBuildState(runtimeSnapshotState, snapshot, /* @__PURE__ */ new Map());
if (changed) invalidateGulpSourceCandidates();
if (!changed && runtimeSetInitialized) return runtimeSet;
if (!runtimeSetDirty) try {
runtimeSet = await bundleRuntimeClassSetManager.sync(runtimeState.tailwindRuntime, snapshot);
runtimeSetInitialized = true;
return runtimeSet;
} catch (error) {
debug("gulp incremental runtime set sync failed, fallback to collect: %O", error);
await bundleRuntimeClassSetManager.reset();
}
return refreshRuntimeSet({ forceCollect: true });
}
async function refreshGulpV4SourceCandidates(forceRefresh = false) {
const root = opts.tailwindcssBasedir ?? node_process.default.cwd();
const sourceScan = await require_options.resolveSourceScanEntries(opts, runtimeState.tailwindRuntime, { root });
const nextSignature = cache.computeHash(JSON.stringify({
root,
entries: sourceScan?.entries,
inlineCandidates: sourceScan?.inlineCandidates ? {
included: [...sourceScan.inlineCandidates.included].sort(),
excluded: [...sourceScan.inlineCandidates.excluded].sort()
} : void 0,
explicit: sourceScan?.explicit ?? false,
dependencies: [...sourceScan?.dependencies ?? []].sort()
}));
if (!forceRefresh && cachedGulpSourceCandidateSignature === nextSignature && cachedGulpSourceCandidateGetter) return cachedGulpSourceCandidateGetter;
const collector = require_v4_generation_core.createSourceCandidateCollector({
bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues,
customAttributesEntities: opts.customAttributesEntities,
disabledDefaultTemplateHandler: opts.disabledDefaultTemplateHandler
});
await collector.scanRoot({
entries: sourceScan?.entries,
explicit: sourceScan?.explicit,
root
});
collector.syncInline(sourceScan?.inlineCandidates);
cachedGulpSourceCandidateSignature = nextSignature;
cachedGulpSourceCandidateGetter = (entries) => collector.valuesForEntries(entries);
cachedGulpSourceCandidateSourceGetter = (entries) => collector.sourcesForEntries(entries);
return cachedGulpSourceCandidateGetter;
}
function createRuntimeSetHash(rawSource, nextRuntimeSet, sourceTraceSignature, sourceCandidateSignature, outputSignature) {
return cache.computeHash([
rawSource,
require_tailwindcss.getRuntimeClassSetSignature(runtimeState.tailwindRuntime),
[...nextRuntimeSet].sort().join("\n"),
sourceTraceSignature ?? "css-source-trace:0",
sourceCandidateSignature ?? "gulp-source-candidates:0",
outputSignature ?? "gulp-output:0"
].join("\n\n"));
}
async function registerAutoCssSource(file, rawSource) {
if (hasInitialTailwindCssRoots || (runtimeState.tailwindRuntime.majorVersion ?? 0) < 4 || !file.path || !require_generator.hasTailwindRootDirectives(rawSource)) return false;
const sourceFile = node_path.default.resolve(file.path);
const sourceCss = require_generator.normalizeTailwindSourceForGenerator(require_generator.normalizeTailwindConfigDirectives(rawSource, node_path.default.dirname(sourceFile)), { importFallback: true });
const config = runtimeState.tailwindRuntime.options?.tailwindcss?.config;
const generatorSourceCss = require_generator.prependConfigDirective((0, _weapp_tailwindcss_postcss.splitLocalCssImports)(sourceCss)?.source ?? sourceCss, config);
if (!require_generator.upsertTailwindV4CssSource(opts, {
file: sourceFile,
base: node_path.default.dirname(sourceFile),
css: generatorSourceCss
})) return false;
runtimeSetInitialized = false;
runtimeSetDirty = true;
await bundleRuntimeClassSetManager.reset();
debug("detected tailwindcss v4 css source from gulp css file: %s", file.path);
return true;
}
function resolveModuleGraphOptions(moduleGraph) {
if (moduleGraph) return moduleGraph;
if (!cachedDefaultModuleGraphOptions) cachedDefaultModuleGraphOptions = createGulpModuleGraphOptions(opts);
return cachedDefaultModuleGraphOptions;
}
function resolveWxssHandlerOptions(options) {
const styleHandlerMajorVersion = require_style_options.normalizeStyleHandlerMajorVersion(runtimeState.tailwindRuntime.majorVersion);
const majorVersion = styleHandlerMajorVersion ?? "unknown";
if (!options || Object.keys(options).length === 0) {
let cached = defaultStyleHandlerOptionsCache.get(majorVersion);
if (!cached) {
cached = styleHandlerMajorVersion === void 0 ? {} : { majorVersion: styleHandlerMajorVersion };
defaultStyleHandlerOptionsCache.set(majorVersion, cached);
}
return cached;
}
return styleHandlerMajorVersion === void 0 ? { ...options } : {
majorVersion: styleHandlerMajorVersion,
...options
};
}
function resolveGulpStyleOutputExtension(file) {
return typeof opts.cssMatcher === "function" && opts.cssMatcher(node_path.default.basename(file.path)) ? node_path.default.extname(file.path) : void 0;
}
function resolveGulpMatcherName(file) {
return (file.relative || node_path.default.basename(file.path)).replaceAll(node_path.default.sep, "/");
}
function resolveWxssFileHandlerOptions(file, rawSource, options) {
const resolved = resolveWxssHandlerOptions(options);
const sourceFile = file.path ? node_path.default.resolve(file.path) : void 0;
const sourceOptions = sourceFile ? {
outputRoot: node_path.default.resolve(file.cwd ?? node_process.default.cwd()),
sourceCss: rawSource,
sourceFile
} : void 0;
if (resolved.isMainChunk !== void 0) return {
...resolved,
postcssOptions: {
...resolved.postcssOptions,
options: {
...resolved.postcssOptions?.options,
...sourceFile ? { from: sourceFile } : {}
}
},
...sourceOptions ? { sourceOptions } : {}
};
return {
...resolved,
isMainChunk: opts.mainCssChunkMatcher(resolveGulpMatcherName(file), opts.appType),
postcssOptions: {
...resolved.postcssOptions,
options: {
...resolved.postcssOptions?.options,
...sourceFile ? { from: sourceFile } : {}
}
},
...sourceOptions ? { sourceOptions } : {}
};
}
function resolveWxssUserHandlerOptions(options) {
return {
...resolveWxssHandlerOptions(options),
isMainChunk: false
};
}
function resolveWxmlHandlerOptions(options) {
if (!options || Object.keys(options).length === 0) {
if (cachedDefaultTemplateRuntimeSet !== runtimeSet || !cachedDefaultTemplateHandlerOptions) {
cachedDefaultTemplateRuntimeSet = runtimeSet;
cachedDefaultTemplateHandlerOptions = { runtimeSet };
}
return cachedDefaultTemplateHandlerOptions;
}
return {
runtimeSet,
...options
};
}
function resolveGulpTransformTimingDetails(phase) {
return { memoryDebug: resolveGulpMemoryDebugStats({
cache,
defaultStyleHandlerOptionsCache,
gulpProcessCacheKeys,
phase,
runtimeSet,
runtimeSourceHashByFile: runtimeSnapshotState.sourceHashByFile,
runtimeSourcesByFile
}) };
}
function rememberCompilationScope(sourceFile, scopeId) {
touchMapEntry(compilationScopeBySourceFile, node_path.default.resolve(sourceFile), scopeId);
while (compilationScopeBySourceFile.size > GULP_COMPILATION_SCOPE_CACHE_MAX) {
const oldestSourceFile = compilationScopeBySourceFile.keys().next().value;
if (typeof oldestSourceFile !== "string") break;
compilationScopeBySourceFile.delete(oldestSourceFile);
}
}
/** 记录 Gulp watcher 提交的源码或生成依赖变化。 */
async function watchChange(id, change = { event: "update" }) {
require_v4_generation_core.beginCompilerShadowRun(runtimeState);
const file = node_path.default.resolve(id);
const affectedScopes = require_v4_generation_core.recordCompilationDependencyChanges(runtimeState, require_v4_generation_core.createCompilationDependencyChanges([file]));
invalidateGulpSourceCandidates();
if (change.event === "delete") {
const removedRuntimeSource = runtimeSourcesByFile.delete(file);
const removedCssSource = require_generator.removeTailwindV4CssSource(opts, file);
const removedScopeId = compilationScopeBySourceFile.get(file);
if (removedScopeId) {
require_v4_generation_core.invalidateCompilationScope(runtimeState, removedScopeId);
compilationScopeBySourceFile.delete(file);
}
require_hmr_timing.removeRuntimeCompilationBuildStateFiles(runtimeSnapshotState, [file]);
generatedCssPreflightModeByFile.delete(file);
gulpProcessCacheKeys.delete(file);
cache.instance.delete(file);
cache.hashMap.delete(file);
if (removedRuntimeSource || removedCssSource) {
runtimeSetInitialized = false;
runtimeSetDirty = true;
await bundleRuntimeClassSetManager.reset();
}
}
return affectedScopes;
}
return {
...createGulpFileTransforms({
cache,
createRuntimeSetHash,
debug,
generatedCssPreflightModeByFile,
getCompilationDependencyRevision: (scopeId) => require_v4_generation_core.getCompilationScopeDependencyRevision(runtimeState, scopeId),
getSourceCandidateGetter: () => cachedGulpSourceCandidateGetter,
getSourceCandidateSourceGetter: () => cachedGulpSourceCandidateSourceGetter,
getRuntimeSet: () => runtimeSet,
gulpProcessCacheKeys,
opts,
refreshGulpV4SourceCandidates,
refreshRuntimeSet,
refreshRuntimeSetForSource,
registerAutoCssSource,
rememberCompilationScope,
resolveGulpStyleOutputExtension,
resolveGulpTransformTimingDetails,
resolveModuleGraphOptions,
resolveWxmlHandlerOptions,
resolveWxssFileHandlerOptions,
resolveWxssUserHandlerOptions,
runtimeState
}),
beginCompilerShadowRun: () => require_v4_generation_core.beginCompilerShadowRun(runtimeState),
completeCompilerShadowRun: (revision) => require_hmr_timing.finalizeCompilerShadowRun(runtimeState, { revision }),
async dispose() {
await require_v4_generation_core.disposeCompilerOwner(runtimeState);
await bundleRuntimeClassSetManager.reset();
},
getCompilerShadowRunSnapshot: () => require_v4_generation_core.getCompilerShadowRunSnapshot(runtimeState),
watchChange
};
}
//#endregion
//#region src/bundlers/gulp/frameworks/native/index.ts
function createNativeGulpFrameworkPlugins(options = {}) {
return createNativeGulpPlugins(options);
}
//#endregion
//#region src/bundlers/gulp/index.ts
/**
* @name weapp-tw-gulp
* @description Gulp 入口直接创建 native framework，具体 stream 组合由 frameworks/native 拥有。
* @link https://tw.icebreaker.top/docs/quick-start/frameworks/native
*/
function createPlugins(options = {}) {
return createNativeGulpFrameworkPlugins(options);
}
//#endregion
Object.defineProperty(exports, "createPlugins", {
enumerable: true,
get: function() {
return createPlugins;
}
});