pax_global_header 0000666 0000000 0000000 00000000064 14317644650 0014524 g ustar 00root root 0000000 0000000 52 comment=21caa3e55b3295490abd5624b1838fccfe309dda
less-loader-11.1.0/ 0000775 0000000 0000000 00000000000 14317644650 0014016 5 ustar 00root root 0000000 0000000 less-loader-11.1.0/.editorconfig 0000664 0000000 0000000 00000000302 14317644650 0016466 0 ustar 00root root 0000000 0000000 # editorconfig.org
[*]
charset = utf-8
indent_style = space
indent_size = 2
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true
[*.md]
trim_trailing_whitespace = false less-loader-11.1.0/.eslintignore 0000664 0000000 0000000 00000000054 14317644650 0016520 0 ustar 00root root 0000000 0000000 /coverage
/dist
/node_modules
/test/fixtures less-loader-11.1.0/.eslintrc.js 0000664 0000000 0000000 00000000147 14317644650 0016257 0 ustar 00root root 0000000 0000000 module.exports = {
root: true,
extends: ["@webpack-contrib/eslint-config-webpack", "prettier"],
};
less-loader-11.1.0/.gitattributes 0000664 0000000 0000000 00000000101 14317644650 0016701 0 ustar 00root root 0000000 0000000 * text=auto
bin/* eol=lf
yarn.lock -diff
package-lock.json -diff
less-loader-11.1.0/.github/ 0000775 0000000 0000000 00000000000 14317644650 0015356 5 ustar 00root root 0000000 0000000 less-loader-11.1.0/.github/CODEOWNERS 0000664 0000000 0000000 00000000310 14317644650 0016743 0 ustar 00root root 0000000 0000000 # These are the default owners for everything in
# webpack-contrib
@webpack-contrib/org-maintainers
# Add repository specific users / groups
# below here for libs that are not maintained by the org.
less-loader-11.1.0/.github/CONTRIBUTING.md 0000664 0000000 0000000 00000016072 14317644650 0017615 0 ustar 00root root 0000000 0000000 # Contributing in @webpack-contrib
We'd always love contributions to further improve the webpack / webpack-contrib ecosystem!
Here are the guidelines we'd like you to follow:
- [Questions and Problems](#question)
- [Issues and Bugs](#issue)
- [Feature Requests](#feature)
- [Pull Request Submission Guidelines](#submit-pr)
- [Commit Message Conventions](#commit)
## ():
```
The **header** is mandatory and the **scope** of the header is optional.
Any line of the commit message cannot be longer 100 characters! This allows the message to be easier
to read on GitHub as well as in various git tools.
The footer should contain a [closing reference to an issue](https://help.github.com/articles/closing-issues-via-commit-messages/) if any.
Examples:
```
docs(readme): update install instructions
```
```
fix: refer to the `entrypoint` instead of the first `module`
```
### Revert
If the commit reverts a previous commit, it should begin with `revert:`, followed by the header of the reverted commit.
In the body it should say: `This reverts commit .`, where the hash is the SHA of the commit being reverted.
### Type
Must be one of the following:
- **build**: Changes that affect the build system or external dependencies (example scopes: babel, npm)
- **chore**: Changes that fall outside of build / docs that do not effect source code (example scopes: package, defaults)
- **ci**: Changes to our CI configuration files and scripts (example scopes: circleci, travis)
- **docs**: Documentation only changes (example scopes: readme, changelog)
- **feat**: A new feature
- **fix**: A bug fix
- **perf**: A code change that improves performance
- **refactor**: A code change that neither fixes a bug nor adds a feature
- **revert**: Used when reverting a committed change
- **style**: Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons)
- **test**: Addition of or updates to Jest tests
### Scope
The scope is subjective & depends on the `type` see above. A good example would be a change to a particular class / module.
### Subject
The subject contains a succinct description of the change:
- use the imperative, present tense: "change" not "changed" nor "changes"
- don't capitalize the first letter
- no dot (.) at the end
### Body
Just as in the **subject**, use the imperative, present tense: "change" not "changed" nor "changes".
The body should include the motivation for the change and contrast this with previous behavior.
### Footer
The footer should contain any information about **Breaking Changes** and is also the place to
reference GitHub issues that this commit **Closes**.
**Breaking Changes** should start with the word `BREAKING CHANGE:` with a space or two newlines. The rest of the commit message is then used for this.
Example
```
BREAKING CHANGE: Updates to `Chunk.mapModules`.
This release is not backwards compatible with `Webpack 2.x` due to breaking changes in webpack/webpack#4764
Migration: see webpack/webpack#5225
```
## Testing Your Pull Request
You may have the need to test your changes in a real-world project or dependent
module. Thankfully, Github provides a means to do this. Add a dependency to the
`package.json` for such a project as follows:
```json
{
"devDependencies": {
"less-loader": "webpack-contrib/less-loader#{id}/head"
}
}
```
Where `{id}` is the # ID of your Pull Request.
## Contributor License Agreement
When submitting your contribution, a CLA (Contributor License Agreement) bot will come by to verify that you signed the [CLA](https://cla.js.foundation/webpack-contrib/less-loader).
If it is your first time, it will link you to the right place to sign it.
However, if you have committed your contributions using an email that is not the same as your email used on GitHub, the CLA bot can't accept your contribution.
Run `git config user.email` to see your Git email, and verify it with [your GitHub email](https://github.com/settings/emails).
## Thanks
For your interest, time, understanding, and for following this simple guide.
less-loader-11.1.0/.github/FUNDING.yml 0000664 0000000 0000000 00000000031 14317644650 0017165 0 ustar 00root root 0000000 0000000 open_collective: webpack
less-loader-11.1.0/.github/ISSUE_TEMPLATE.md 0000664 0000000 0000000 00000001316 14317644650 0020064 0 ustar 00root root 0000000 0000000
less-loader-11.1.0/.github/ISSUE_TEMPLATE/ 0000775 0000000 0000000 00000000000 14317644650 0017541 5 ustar 00root root 0000000 0000000 less-loader-11.1.0/.github/ISSUE_TEMPLATE/BUG.md 0000664 0000000 0000000 00000002675 14317644650 0020512 0 ustar 00root root 0000000 0000000 ---
name: 🐛 Bug Report
about: Something went awry and you'd like to tell us about it.
---
### Bug report
### Actual Behavior
### Expected Behavior
### How Do We Reproduce?
### Please paste the results of `npx webpack-cli info` here, and mention other relevant information
less-loader-11.1.0/.github/ISSUE_TEMPLATE/DOCS.md 0000664 0000000 0000000 00000001530 14317644650 0020612 0 ustar 00root root 0000000 0000000 ---
name: 📚 Documentation
about: Are the docs lacking or missing something? Do they need some new 🔥 hotness? Tell us here.
---
Documentation Is:
- [ ] Missing
- [ ] Needed
- [ ] Confusing
- [ ] Not Sure?
### Please Explain in Detail...
### Your Proposal for Changes
less-loader-11.1.0/.github/ISSUE_TEMPLATE/FEATURE.md 0000664 0000000 0000000 00000001330 14317644650 0021153 0 ustar 00root root 0000000 0000000 ---
name: ✨ Feature Request
about: Suggest an idea for this project
---
### Feature Proposal
### Feature Use Case
### Please paste the results of `npx webpack-cli info` here, and mention other relevant information
less-loader-11.1.0/.github/ISSUE_TEMPLATE/MODIFICATION.md 0000664 0000000 0000000 00000001527 14317644650 0021735 0 ustar 00root root 0000000 0000000 ---
name: 🔧 Modification Request
about: Would you like something work differently? Have an alternative approach? This is the template for you.
---
### Modification Proposal
### Expected Behavior / Situation
### Actual Behavior / Situation
### Please paste the results of `npx webpack-cli info` here, and mention other relevant information
less-loader-11.1.0/.github/ISSUE_TEMPLATE/SUPPORT.md 0000664 0000000 0000000 00000001005 14317644650 0021233 0 ustar 00root root 0000000 0000000 ---
name: 🆘 Support, Help, and Advice
about: 👉🏽 Need support, help, or advice? Don't open an issue! Head to https://github.com/webpack/webpack/discussions, StackOverflow or https://gitter.im/webpack/webpack.
---
Hey there! If you need support, help, or advice then this is not the place to ask.
Please visit [Discussions](https://github.com/webpack/webpack/discussions), [StackOverflow](https://stackoverflow.com/questions/tagged/webpack)
or [the Webpack Gitter](https://gitter.im/webpack/webpack) instead.
less-loader-11.1.0/.github/PULL_REQUEST_TEMPLATE.md 0000664 0000000 0000000 00000001563 14317644650 0021164 0 ustar 00root root 0000000 0000000
This PR contains a:
- [ ] **bugfix**
- [ ] new **feature**
- [ ] **code refactor**
- [ ] **test update**
- [ ] **typo fix**
- [ ] **metadata update**
### Motivation / Use-Case
### Breaking Changes
### Additional Info
less-loader-11.1.0/.github/workflows/ 0000775 0000000 0000000 00000000000 14317644650 0017413 5 ustar 00root root 0000000 0000000 less-loader-11.1.0/.github/workflows/cancel.yml 0000664 0000000 0000000 00000000665 14317644650 0021372 0 ustar 00root root 0000000 0000000 name: Cancel
on:
push:
branches:
- master
- next
pull_request:
branches:
- master
- next
permissions: {} # none
jobs:
cancel:
permissions:
actions: write
name: Cancel Previous Runs
runs-on: ubuntu-latest
timeout-minutes: 3
steps:
- uses: styfle/cancel-workflow-action@0.10.0
with:
workflow_id: nodejs.yml
access_token: ${{ github.token }}
less-loader-11.1.0/.github/workflows/nodejs.yml 0000664 0000000 0000000 00000004027 14317644650 0021423 0 ustar 00root root 0000000 0000000 name: less-loader
on:
push:
branches:
- master
- next
pull_request:
branches:
- master
- next
permissions:
contents: read
jobs:
lint:
name: Lint - ${{ matrix.os }} - Node v${{ matrix.node-version }}
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
strategy:
matrix:
os: [ubuntu-latest]
node-version: [16.x]
runs-on: ${{ matrix.os }}
steps:
- uses: actions/checkout@v3
with:
fetch-depth: 0
- name: Use Node.js ${{ matrix.node-version }}
uses: actions/setup-node@v3
with:
node-version: ${{ matrix.node-version }}
cache: "npm"
- name: Install dependencies
run: npm ci
- name: Lint
run: npm run lint
- name: Security audit
run: npm run security
- name: Check commit message
uses: wagoid/commitlint-github-action@v5
test:
name: Test - ${{ matrix.os }} - Node v${{ matrix.node-version }}, Webpack ${{ matrix.webpack-version }}
strategy:
matrix:
os: [ubuntu-latest, windows-latest, macos-latest]
node-version: [14.x, 16.x, 18.x]
webpack-version: [latest]
runs-on: ${{ matrix.os }}
steps:
- name: Setup Git
if: matrix.os == 'windows-latest'
run: git config --global core.autocrlf input
- uses: actions/checkout@v3
- name: Use Node.js ${{ matrix.node-version }}
uses: actions/setup-node@v3
with:
node-version: ${{ matrix.node-version }}
cache: "npm"
- name: Install dependencies
run: npm ci
- name: Install webpack ${{ matrix.webpack-version }}
if: matrix.webpack-version != 'latest'
run: npm i webpack@${{ matrix.webpack-version }}
- name: Run tests for webpack version ${{ matrix.webpack-version }}
run: npm run test:coverage -- --ci
- name: Submit coverage data to codecov
uses: codecov/codecov-action@v3
with:
token: ${{ secrets.CODECOV_TOKEN }}
less-loader-11.1.0/.gitignore 0000664 0000000 0000000 00000000620 14317644650 0016004 0 ustar 00root root 0000000 0000000 lib-cov
*.seed
*.log
*.csv
*.dat
*.out
*.pid
*.gz
pids
logs
results
npm-debug.log
/node_modules
/coverage
.idea
.nyc_output
npm-debug.log*
yarn-debug.log*
.eslintcache
/coverage
/dist
/local
/reports
/test/fixtures/css
/test/fixtures/generated-1.less
/test/fixtures/generated-2.less
/test/fixtures/generated-3.less
/test/output
.DS_Store
Thumbs.db
.vscode
*.sublime-project
*.sublime-workspace
*.iml
less-loader-11.1.0/.husky/ 0000775 0000000 0000000 00000000000 14317644650 0015237 5 ustar 00root root 0000000 0000000 less-loader-11.1.0/.husky/commit-msg 0000775 0000000 0000000 00000000120 14317644650 0017232 0 ustar 00root root 0000000 0000000 #!/bin/sh
. "$(dirname "$0")/_/husky.sh"
npx --no-install commitlint --edit $1
less-loader-11.1.0/.husky/pre-commit 0000775 0000000 0000000 00000000107 14317644650 0017237 0 ustar 00root root 0000000 0000000 #!/bin/sh
. "$(dirname "$0")/_/husky.sh"
npx --no-install lint-staged
less-loader-11.1.0/.prettierignore 0000664 0000000 0000000 00000000071 14317644650 0017057 0 ustar 00root root 0000000 0000000 /coverage
/dist
/node_modules
/test/fixtures
CHANGELOG.md less-loader-11.1.0/CHANGELOG.md 0000664 0000000 0000000 00000041527 14317644650 0015640 0 ustar 00root root 0000000 0000000 # Changelog
All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
## [11.1.0](https://github.com/webpack-contrib/less-loader/compare/v11.0.0...v11.1.0) (2022-10-06)
### Features
* allow to extend `conditionNames` ([#488](https://github.com/webpack-contrib/less-loader/issues/488)) ([43cd20c](https://github.com/webpack-contrib/less-loader/commit/43cd20c7c321c07d98df73bd16405f46f86cfc4f))
## [11.0.0](https://github.com/webpack-contrib/less-loader/compare/v10.2.0...v11.0.0) (2022-05-17)
### ⚠ BREAKING CHANGES
* minimum supported `Node.js` version is `14.15.0`
## [10.2.0](https://github.com/webpack-contrib/less-loader/compare/v10.1.0...v10.2.0) (2021-10-18)
### Features
* use webpack logger for logging ([#444](https://github.com/webpack-contrib/less-loader/issues/444)) ([239c737](https://github.com/webpack-contrib/less-loader/commit/239c737e2ede1d17d83a6d11a6bd11211cf7d77d))
## [10.1.0](https://github.com/webpack-contrib/less-loader/compare/v10.0.1...v10.1.0) (2021-10-11)
### Features
* add `link` field in schema ([#429](https://github.com/webpack-contrib/less-loader/issues/429)) ([8580731](https://github.com/webpack-contrib/less-loader/commit/858073159cc5aef320e7682798bc987f93ef4817))
### Bug Fixes
* only call `addDependency` on absolute paths ([fa11ce7](https://github.com/webpack-contrib/less-loader/commit/fa11ce7670ed8cae484e3435be05713deb199954))
### [10.0.1](https://github.com/webpack-contrib/less-loader/compare/v10.0.0...v10.0.1) (2021-07-02)
### Bug Fixes
* memory leak ([#426](https://github.com/webpack-contrib/less-loader/issues/426)) ([d74f740](https://github.com/webpack-contrib/less-loader/commit/d74f740c100c4006b00dfb3e02c6d5aaf8713519))
## [10.0.0](https://github.com/webpack-contrib/less-loader/compare/v9.1.0...v10.0.0) (2021-06-17)
### ⚠ BREAKING CHANGES
* `less.webpackLoaderContext` was removed, please use `pluginManager.webpackLoaderContext`
### Bug Fixes
* memory usage ([#425](https://github.com/webpack-contrib/less-loader/issues/425)) ([9c03b59](https://github.com/webpack-contrib/less-loader/commit/9c03b5914240e4e18bebd2d3a47ec0a650a67701))
## [9.1.0](https://github.com/webpack-contrib/less-loader/compare/v9.0.0...v9.1.0) (2021-06-10)
### Features
* allow to use `String` value for the `implementation` option ([465ffc4](https://github.com/webpack-contrib/less-loader/commit/465ffc4052642d799bb29a85056517db31ee1bf5))
## [9.0.0](https://github.com/webpack-contrib/less-loader/compare/v8.1.1...v9.0.0) (2021-05-13)
### ⚠ BREAKING CHANGES
* minimum supported `Node.js` version is `12.13.0`
### [8.1.1](https://github.com/webpack-contrib/less-loader/compare/v8.1.0...v8.1.1) (2021-04-15)
### Bug Fixes
* deprecation warning ([#415](https://github.com/webpack-contrib/less-loader/issues/415)) ([87a4f25](https://github.com/webpack-contrib/less-loader/commit/87a4f25e2c8343ae2c75486749e57c2d10b1490d))
## [8.1.0](https://github.com/webpack-contrib/less-loader/compare/v8.0.0...v8.1.0) (2021-04-09)
### Features
* added the `pluginManager.webpackLoaderContext` property for `less` plugin developers, deprecated the `less.webpackLoaderContext` property, it fixed memory leak, please read [this](https://github.com/webpack-contrib/less-loader#plugins) ([#412](https://github.com/webpack-contrib/less-loader/issues/412)) ([e576240](https://github.com/webpack-contrib/less-loader/commit/e5762404093ec6246079c6b975c9f93c0a521bd9))
## [8.0.0](https://github.com/webpack-contrib/less-loader/compare/v7.3.0...v8.0.0) (2021-02-01)
### Notes
* using `~` is deprecated and can be removed from your code (**we recommend it**), but we still support it for historical reasons.
Why you can removed it?
The loader will first try to resolve `@import` as relative, if it cannot be resolved, the loader will try to resolve `@import` inside [`node_modules`](https://webpack.js.org/configuration/resolve/#resolve-modules).
### ⚠ BREAKING CHANGES
* minimum supported `webpack` version is `5`
### Features
* supported the [`resolve.byDependency`](https://webpack.js.org/configuration/resolve/#resolvebydependency) option, you can setup `{ resolve: { byDependency: { less: { mainFiles: ['custom', '...'] } } } }`
## [7.3.0](https://github.com/webpack-contrib/less-loader/compare/v7.2.1...v7.3.0) (2021-01-21)
### Features
* added the `implementation` option ([84d957c](https://github.com/webpack-contrib/less-loader/commit/84d957cfe4fbd6c97619c647d0dd0917b99408ae))
### [7.2.1](https://github.com/webpack-contrib/less-loader/compare/v7.2.0...v7.2.1) (2020-12-28)
### Bug Fixes
* errors from less ([#401](https://github.com/webpack-contrib/less-loader/issues/401)) ([ce31aca](https://github.com/webpack-contrib/less-loader/commit/ce31aca7aada70a8cc267449954ab38b642cd4ba))
## [7.2.0](https://github.com/webpack-contrib/less-loader/compare/v7.1.0...v7.2.0) (2020-12-23)
### Features
* add less ^4.0 to peerDependencies ([#398](https://github.com/webpack-contrib/less-loader/issues/398)) ([3d1abb7](https://github.com/webpack-contrib/less-loader/commit/3d1abb7be041e44fce59b2109d02eada1451a4e4))
## [7.1.0](https://github.com/webpack-contrib/less-loader/compare/v7.0.2...v7.1.0) (2020-11-11)
### Features
* allow the `additionalData` to be async ([#391](https://github.com/webpack-contrib/less-loader/issues/391)) ([62c6934](https://github.com/webpack-contrib/less-loader/commit/62c6934367eb4dd0d4f3155ed2bb5f3e065aafba))
### [7.0.2](https://github.com/webpack-contrib/less-loader/compare/v7.0.1...v7.0.2) (2020-10-09)
### Chore
* update `schema-utils`
### [7.0.1](https://github.com/webpack-contrib/less-loader/compare/v7.0.0...v7.0.1) (2020-09-03)
### Bug Fixes
* normalize `sources` in source maps ([877d99a](https://github.com/webpack-contrib/less-loader/commit/877d99a380deac92e07c41429a9b0c5f0bba2710))
## [7.0.0](https://github.com/webpack-contrib/less-loader/compare/v6.2.0...v7.0.0) (2020-08-25)
### ⚠ BREAKING CHANGES
* move `less` to `peerDependencies`, the `implementation` option was removed
* `prependData` and `appendData` option were removed in favor the `additionaldata` option
### Features
* added `webpackImporter` option ([#377](https://github.com/webpack-contrib/less-loader/issues/377)) ([12dca5b](https://github.com/webpack-contrib/less-loader/commit/12dca5bb573740472cff8176b7aade184c773ebc))
* added loader context in less plugins ([#378](https://github.com/webpack-contrib/less-loader/issues/378)) ([7b7fc5e](https://github.com/webpack-contrib/less-loader/commit/7b7fc5e841a2c7c587a980648056ed4762014e9d))
* added `additionaldata` option ([#374](https://github.com/webpack-contrib/less-loader/issues/374)) ([2785803](https://github.com/webpack-contrib/less-loader/commit/27858037a2e307fdf437604300f14c8233df4568))
## [6.2.0](https://github.com/webpack-contrib/less-loader/compare/v6.1.3...v6.2.0) (2020-07-03)
### Features
* support condition names from `package.json` ([#369](https://github.com/webpack-contrib/less-loader/issues/369)) ([671395d](https://github.com/webpack-contrib/less-loader/commit/671395d6a82425ba4408d1329d8cbfa07dfd9153))
### [6.1.3](https://github.com/webpack-contrib/less-loader/compare/v6.1.2...v6.1.3) (2020-06-29)
### Bug Fixes
* revert restrictions ([e758837](https://github.com/webpack-contrib/less-loader/commit/e75883706fc3d3bb2b6283a727a405216473362e))
### [6.1.2](https://github.com/webpack-contrib/less-loader/compare/v6.1.1...v6.1.2) (2020-06-22)
### Bug Fixes
* ignore watch for remove URLs ([3946937](https://github.com/webpack-contrib/less-loader/commit/39469376e28cd0e38162f7bdf8935d343830a40e))
* resolution logic ([2c3a23a](https://github.com/webpack-contrib/less-loader/commit/2c3a23a440cbdad1edb8b232864cb0233a266782))
* resolve absolute and root relative imports ([3d01b82](https://github.com/webpack-contrib/less-loader/commit/3d01b82fae335d5d69d6290911e788debc732182))
### [6.1.1](https://github.com/webpack-contrib/less-loader/compare/v6.1.0...v6.1.1) (2020-06-11)
### Bug Fixes
* do not rebuilt unmodified files on windows in watch mode ([6537a3d](https://github.com/webpack-contrib/less-loader/commit/6537a3d66559464af9b9a25f4bdda8691e8d9407))
## [6.1.0](https://github.com/webpack-contrib/less-loader/compare/v6.0.0...v6.1.0) (2020-05-07)
### Features
* new `implementation` option ([#354](https://github.com/webpack-contrib/less-loader/issues/354)) ([d2de80f](https://github.com/webpack-contrib/less-loader/commit/d2de80f9fe6ee11e784260dbda960853ebd2449b))
### Bug Fixes
* respect third-party plugins for `Less` ([#353](https://github.com/webpack-contrib/less-loader/issues/353)) ([d0db4f9](https://github.com/webpack-contrib/less-loader/commit/d0db4f9839c4921440c9a0fdc00fd00bc5a6fbb8))
## [6.0.0](https://github.com/webpack-contrib/less-loader/compare/v5.0.0...v6.0.0) (2020-04-24)
### ⚠ BREAKING CHANGES
* minimum supported Node.js version is `10.13`,
* minimum support webpack version is `4`
* `2` version of `less` is not supported anymore
* using `3` versin of `less` by default, so you don't need to have `less` in your `package.json`, we already supply it
* move less-specific options to the `lessOptions` option, please look at [README](https://github.com/webpack-contrib/less-loader#lessoptions)
### Features
* the `paths` options now works with webpack resolver ([3931470](https://github.com/webpack-contrib/less-loader/commit/393147064672ace986ec84aca21f69f0ab819a9c))
* allow a function to be used for `lessOptions` ([#325](https://github.com/webpack-contrib/less-loader/issues/325)) ([a6be94a](https://github.com/webpack-contrib/less-loader/commit/a6be94a6da291a27026415d509249e0203e977ad))
* added the `appendData` option ([#336](https://github.com/webpack-contrib/less-loader/issues/336)) ([fb94605](https://github.com/webpack-contrib/less-loader/commit/fb946051bb4d52a6f9a93fe40a8cd09a56a2c5f1))
* added the `prependData` option ([#327](https://github.com/webpack-contrib/less-loader/issues/327)) ([9df8755](https://github.com/webpack-contrib/less-loader/commit/9df87554ee1ac57d2c32743049174da20e8a8a61))
* support `less` and `style` fields in `package.json`
* support `index.less` file for packages
### Bug Fixes
* support import aliases without tilde ([#335](https://github.com/webpack-contrib/less-loader/issues/335)) ([24021cd](https://github.com/webpack-contrib/less-loader/commit/24021cdb9dc0496fcebd6966516ff66584525cf3))
* do not crash on remotely imports ([#333](https://github.com/webpack-contrib/less-loader/issues/333)) ([8e020e9](https://github.com/webpack-contrib/less-loader/commit/8e020e9cf794d958024cc91ad490b621d5170878))
* add webpack v5 support ([#317](https://github.com/webpack-contrib/less-loader/issues/317)) ([f0b42b4](https://github.com/webpack-contrib/less-loader/commit/f0b42b4e64dceed0bbb2557c0d88d1c36fe3e553))
* first resolve an import using less resolver, then using webpack resolver ([#340](https://github.com/webpack-contrib/less-loader/issues/340)) ([443bd5a](https://github.com/webpack-contrib/less-loader/commit/443bd5ac0539ca93a998326754bcd607aaecdf1a))
* fix a resolution for `@import 'package/file.ess';` and `@import './package/file.ess';`
less-loader-11.1.0/test/fixtures/source-map.less 0000664 0000000 0000000 00000000127 14317644650 0021611 0 ustar 00root root 0000000 0000000 @import "some/module";
#it-works:extend(.modules-dir-some-module) {
margin: 10px;
}
less-loader-11.1.0/test/fixtures/url-path.less 0000664 0000000 0000000 00000000226 14317644650 0021272 0 ustar 00root root 0000000 0000000 @import "folder/url-path";
.img1 {
background: url(img.jpg);
}
.img2 {
background: url(some/img.jpg);
}
.img3 {
background: url(../img.jpg);
}
less-loader-11.1.0/test/fixtures/watch.less 0000664 0000000 0000000 00000000036 14317644650 0020643 0 ustar 00root root 0000000 0000000 @import 'package/style.less';
less-loader-11.1.0/test/helpers/ 0000775 0000000 0000000 00000000000 14317644650 0016437 5 ustar 00root root 0000000 0000000 less-loader-11.1.0/test/helpers/compile.js 0000664 0000000 0000000 00000000314 14317644650 0020423 0 ustar 00root root 0000000 0000000 export default (compiler) =>
new Promise((resolve, reject) => {
compiler.run((error, stats) => {
if (error) {
return reject(error);
}
return resolve(stats);
});
});
less-loader-11.1.0/test/helpers/execute.js 0000664 0000000 0000000 00000000742 14317644650 0020442 0 ustar 00root root 0000000 0000000 import Module from "module";
import path from "path";
const parentModule = module;
export default (code) => {
const resource = "test.js";
const module = new Module(resource, parentModule);
// eslint-disable-next-line no-underscore-dangle
module.paths = Module._nodeModulePaths(
path.resolve(__dirname, "../fixtures")
);
module.filename = resource;
// eslint-disable-next-line no-underscore-dangle
module._compile(code, resource);
return module.exports;
};
less-loader-11.1.0/test/helpers/getCodeFromBundle.js 0000664 0000000 0000000 00000001247 14317644650 0022331 0 ustar 00root root 0000000 0000000 import vm from "vm";
import readAsset from "./readAsset";
function getCodeFromBundle(stats, compiler, asset) {
let code = null;
if (
stats &&
stats.compilation &&
stats.compilation.assets &&
stats.compilation.assets[asset || "main.bundle.js"]
) {
code = readAsset(asset || "main.bundle.js", compiler, stats);
}
if (!code) {
throw new Error("Can't find compiled code");
}
const result = vm.runInNewContext(
`${code};\nmodule.exports = lessLoaderExport;`,
{
module: {},
}
);
// eslint-disable-next-line no-underscore-dangle
return result.__esModule ? result.default : result;
}
export default getCodeFromBundle;
less-loader-11.1.0/test/helpers/getCodeFromLess.js 0000664 0000000 0000000 00000010274 14317644650 0022026 0 ustar 00root root 0000000 0000000 import path from "path";
import fs from "fs";
import less from "less";
const pathMap = {
"some/css.css": path.resolve(
__dirname,
"..",
"fixtures",
"node_modules",
"some",
"css.css"
),
"~some/css.css": path.resolve(
__dirname,
"..",
"fixtures",
"node_modules",
"some",
"css.css"
),
"some/module": path.resolve(
__dirname,
"..",
"fixtures",
"node_modules",
"some",
"module.less"
),
"~some/module": path.resolve(
__dirname,
"..",
"fixtures",
"node_modules",
"some",
"module.less"
),
"some/module.less": path.resolve(
__dirname,
"..",
"fixtures",
"node_modules",
"some",
"module.less"
),
"module.less": path.resolve(
__dirname,
"..",
"fixtures",
"node_modules",
"some",
"module.less"
),
"@scope/css.css": path.resolve(
__dirname,
"..",
"fixtures",
"node_modules",
"@scope",
"css.css"
),
"@scope/module": path.resolve(
__dirname,
"..",
"fixtures",
"node_modules",
"@scope",
"module.less"
),
"~fileAlias": path.resolve(__dirname, "..", "fixtures", "img.less"),
fileAlias: path.resolve(__dirname, "..", "fixtures", "img.less"),
"assets/basic.less": path.resolve(__dirname, "..", "fixtures", "basic.less"),
"@{absolutePath}": path.resolve(
__dirname,
"..",
"fixtures",
"import-absolute-target.less"
),
"package/style.less": path.resolve(
__dirname,
"..",
"fixtures",
"node_modules",
"package",
"style.less"
),
"/styles/style.less": path.resolve(__dirname, "..", "fixtures", "basic.less"),
"../../some.file": path.resolve(
__dirname,
"..",
"fixtures",
"folder",
"some.file"
),
"package-with-exports": path.resolve(
__dirname,
"..",
"fixtures",
"node_modules",
"package-with-exports",
"style.less"
),
preferAlias: path.resolve(
__dirname,
"..",
"fixtures",
"prefer-relative",
"index.less"
),
"custom-main-files": path.resolve(
__dirname,
"..",
"fixtures",
"custom-main-files",
"custom.less"
),
};
class ResolvePlugin extends less.FileManager {
supports(filename) {
if (filename[0] === "/" || path.win32.isAbsolute(filename)) {
return true;
}
if (this.isPathAbsolute(filename)) {
return false;
}
return true;
}
// eslint-disable-next-line class-methods-use-this
supportsSync() {
return false;
}
async loadFile(filename, ...args) {
const result =
pathMap[filename] || path.resolve(__dirname, "..", "fixtures", filename);
return super.loadFile(result, ...args);
}
}
class CustomImportPlugin {
// eslint-disable-next-line class-methods-use-this
install(lessInstance, pluginManager) {
pluginManager.addFileManager(new ResolvePlugin());
}
}
async function getCodeFromLess(testId, options = {}, context = {}) {
let pathToFile;
if (context.packageExportsCustomConditionTestVariant === 1) {
pathToFile = path.resolve(
__dirname,
"..",
"fixtures",
"node_modules/package-with-exports-and-custom-condition/style-1.less"
);
} else if (context.packageExportsCustomConditionTestVariant === 2) {
pathToFile = path.resolve(
__dirname,
"..",
"fixtures",
"node_modules/package-with-exports-and-custom-condition/style-2.less"
);
} else {
pathToFile = path.resolve(__dirname, "..", "fixtures", testId);
}
const defaultOptions = {
plugins: [],
relativeUrls: true,
filename: pathToFile,
};
const lessOptions = options.lessOptions || {};
let data = await fs.promises.readFile(pathToFile);
if (typeof options.additionalData !== "undefined") {
data =
typeof options.additionalData === "function"
? `${await options.additionalData(data, {
rootContext: path.resolve(__dirname, "../fixtures"),
resourcePath: pathToFile,
})}`
: `${options.additionalData}\n${data}`;
}
const mergedOptions = {
...defaultOptions,
...lessOptions,
};
mergedOptions.plugins.unshift(new CustomImportPlugin());
return less.render(data.toString(), mergedOptions);
}
export default getCodeFromLess;
less-loader-11.1.0/test/helpers/getCompiler.js 0000664 0000000 0000000 00000002120 14317644650 0021242 0 ustar 00root root 0000000 0000000 import path from "path";
import webpack from "webpack";
import { createFsFromVolume, Volume } from "memfs";
export default (fixture, loaderOptions = {}, config = {}) => {
const fullConfig = {
mode: "development",
devtool: config.devtool || false,
context: path.resolve(__dirname, "../fixtures"),
entry: path.resolve(__dirname, "../fixtures", fixture),
output: {
path: path.resolve(__dirname, "../outputs"),
filename: "[name].bundle.js",
chunkFilename: "[name].chunk.js",
library: "lessLoaderExport",
},
module: {
rules: [
{
test: /\.less$/i,
rules: [
{
loader: require.resolve("./testLoader"),
},
{
loader: path.resolve(__dirname, "../../src"),
options: loaderOptions || {},
},
],
},
],
},
plugins: [],
...config,
};
const compiler = webpack(fullConfig);
if (!config.outputFileSystem) {
compiler.outputFileSystem = createFsFromVolume(new Volume());
}
return compiler;
};
less-loader-11.1.0/test/helpers/getErrors.js 0000664 0000000 0000000 00000000176 14317644650 0020755 0 ustar 00root root 0000000 0000000 import normalizeErrors from "./normalizeErrors";
export default (stats) => normalizeErrors(stats.compilation.errors.sort());
less-loader-11.1.0/test/helpers/getWarnings.js 0000664 0000000 0000000 00000000200 14317644650 0021255 0 ustar 00root root 0000000 0000000 import normalizeErrors from "./normalizeErrors";
export default (stats) => normalizeErrors(stats.compilation.warnings.sort());
less-loader-11.1.0/test/helpers/index.js 0000664 0000000 0000000 00000001225 14317644650 0020104 0 ustar 00root root 0000000 0000000 import compile from "./compile";
import execute from "./execute";
import getCodeFromBundle from "./getCodeFromBundle";
import getCodeFromLess from "./getCodeFromLess";
import getCompiler from "./getCompiler";
import getErrors from "./getErrors";
import getWarnings from "./getWarnings";
import normalizeErrors from "./normalizeErrors";
import readAsset from "./readAsset";
import readsAssets from "./readAssets";
import validateDependencies from "./validateDependencies";
export {
compile,
execute,
getCodeFromBundle,
getCodeFromLess,
getCompiler,
getErrors,
getWarnings,
normalizeErrors,
readAsset,
readsAssets,
validateDependencies,
};
less-loader-11.1.0/test/helpers/normalizeErrors.js 0000664 0000000 0000000 00000001025 14317644650 0022170 0 ustar 00root root 0000000 0000000 function removeCWD(str) {
const isWin = process.platform === "win32";
let cwd = process.cwd();
if (isWin) {
// eslint-disable-next-line no-param-reassign
str = str.replace(/\\/g, "/");
// eslint-disable-next-line no-param-reassign
cwd = cwd.replace(/\\/g, "/");
}
return str
.replace(/\(from .*?\)/, "(from `replaced original path`)")
.replace(new RegExp(cwd, "g"), "");
}
export default (errors) =>
errors.map((error) =>
removeCWD(error.toString().split("\n").slice(0, 2).join("\n"))
);
less-loader-11.1.0/test/helpers/readAsset.js 0000664 0000000 0000000 00000001004 14317644650 0020703 0 ustar 00root root 0000000 0000000 import path from "path";
export default (asset, compiler, stats) => {
const usedFs = compiler.outputFileSystem;
const outputPath = stats.compilation.outputOptions.path;
let data = "";
let targetFile = asset;
const queryStringIdx = targetFile.indexOf("?");
if (queryStringIdx >= 0) {
targetFile = targetFile.slice(0, queryStringIdx);
}
try {
data = usedFs.readFileSync(path.join(outputPath, targetFile)).toString();
} catch (error) {
data = error.toString();
}
return data;
};
less-loader-11.1.0/test/helpers/readAssets.js 0000664 0000000 0000000 00000000400 14317644650 0021065 0 ustar 00root root 0000000 0000000 import readAsset from "./readAsset";
export default function readAssets(compiler, stats) {
const assets = {};
Object.keys(stats.compilation.assets).forEach((asset) => {
assets[asset] = readAsset(asset, compiler, stats);
});
return assets;
}
less-loader-11.1.0/test/helpers/testLoader.js 0000664 0000000 0000000 00000000327 14317644650 0021105 0 ustar 00root root 0000000 0000000 function testLoader(content, sourceMap) {
const result = { css: content };
if (sourceMap) {
result.map = sourceMap;
}
return `export default ${JSON.stringify(result)}`;
}
module.exports = testLoader;
less-loader-11.1.0/test/helpers/validateDependencies.js 0000664 0000000 0000000 00000000503 14317644650 0023073 0 ustar 00root root 0000000 0000000 const illegalSymbol = process.platform === "win32" ? "/" : "\\";
export default (dependencies) => {
for (const item of Array.from(dependencies)) {
if (item.includes(illegalSymbol)) {
throw new Error(
`The file path "${item}" should not contain "${illegalSymbol}"`
);
}
}
return true;
};
less-loader-11.1.0/test/implementation.test.js 0000664 0000000 0000000 00000003301 14317644650 0021333 0 ustar 00root root 0000000 0000000 import {
compile,
getCodeFromBundle,
getCodeFromLess,
getCompiler,
getErrors,
getWarnings,
} from "./helpers";
describe('"implementation" option', () => {
it("should work", async () => {
const testId = "./basic.less";
const compiler = getCompiler(testId, {
// eslint-disable-next-line global-require
implementation: require("less"),
});
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should work when implementation option is string", async () => {
const testId = "./basic.less";
const compiler = getCompiler(testId, {
implementation: require.resolve("less"),
});
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should throw error when unresolved package", async () => {
const testId = "./basic.less";
const compiler = getCompiler(testId, {
implementation: "unresolved",
});
const stats = await compile(compiler);
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
});
less-loader-11.1.0/test/loader.test.js 0000664 0000000 0000000 00000101626 14317644650 0017565 0 ustar 00root root 0000000 0000000 import path from "path";
import fs from "fs";
import lessPluginGlob from "less-plugin-glob";
import CustomImportPlugin from "./fixtures/folder/customImportPlugin";
import CustomFileLoaderPlugin from "./fixtures/folder/customFileLoaderPlugin";
import {
compile,
getCodeFromBundle,
getCodeFromLess,
getCompiler,
getErrors,
getWarnings,
validateDependencies,
} from "./helpers";
const nodeModulesPath = path.resolve(__dirname, "fixtures", "node_modules");
jest.setTimeout(30000);
describe("loader", () => {
it("should work", async () => {
const testId = "./basic.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should compile data-uri function", async () => {
const testId = "./data-uri.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should transform urls", async () => {
const testId = "./url-path.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should install plugins", async () => {
let pluginInstalled = false;
// Using prototype inheritance here since Less plugins are usually instances of classes
// See https://github.com/webpack-contrib/less-loader/issues/181#issuecomment-288220113
const testPlugin = {
install() {
pluginInstalled = true;
},
};
const testId = "./basic.less";
const compiler = await getCompiler(testId, {
lessOptions: {
plugins: [testPlugin],
},
});
const stats = await compile(compiler);
expect(pluginInstalled).toBe(true);
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should import from plugins", async () => {
const testId = "./empty.less";
const compiler = getCompiler(testId, {
lessOptions: {
plugins: [new CustomImportPlugin()],
},
});
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId, {
lessOptions: {
plugins: [new CustomImportPlugin()],
},
});
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should work third-party plugins as fileLoader", async () => {
const testId = "./file-load.less";
const compiler = getCompiler(testId, {
lessOptions: {
plugins: [new CustomFileLoaderPlugin()],
},
});
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId, {
lessOptions: {
plugins: [new CustomFileLoaderPlugin()],
},
});
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should not alter the original options object", async () => {
const options = { lessOptions: { plugins: [] } };
const copiedOptions = { ...options };
const testId = "./empty.less";
const compiler = getCompiler(testId, options);
const stats = await compile(compiler);
expect(copiedOptions).toEqual(options);
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should resolve all imports", async () => {
const testId = "./import.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should resolve nested imports", async () => {
const testId = "./import-nested.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should work lessOptions.relativeUrls is true", async () => {
const testId = "./import-relative.less";
const compiler = getCompiler(testId, {
lessOptions: {
relativeUrls: true,
},
});
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId, {
lessOptions: {
relativeUrls: true,
},
});
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should work lessOptions.relativeUrls is false", async () => {
const testId = "./import-relative.less";
const compiler = getCompiler(testId, {
lessOptions: {
relativeUrls: false,
},
});
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId, {
lessOptions: {
relativeUrls: false,
},
});
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should resolve all imports from node_modules using webpack's resolver", async () => {
const testId = "./import-webpack.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should resolve aliases in diffrent variants", async () => {
const testId = "./import-webpack-aliases.less";
const compiler = getCompiler(
testId,
{},
{
resolve: {
alias: {
fileAlias: path.resolve(__dirname, "fixtures", "img.less"),
assets: path.resolve(__dirname, "fixtures"),
},
},
}
);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should resolve all imports from the given paths using Less resolver", async () => {
const testId = "./import-paths.less";
const compiler = getCompiler(testId, {
lessOptions: {
paths: [path.resolve(nodeModulesPath, "some")],
},
});
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should not to disable webpack's resolver by passing an empty paths array", async () => {
const testId = "./import-webpack-aliases.less";
const compiler = getCompiler(
testId,
{
lessOptions: {
paths: [],
},
},
{
resolve: {
alias: {
fileAlias: path.resolve(__dirname, "fixtures", "img.less"),
assets: path.resolve(__dirname, "fixtures"),
},
},
}
);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should prefer-relativee imports correctly", async () => {
const testId = "./import-prefer-relative.less";
const compiler = getCompiler(
testId,
{},
{
resolve: {
alias: {
preferAlias: "prefer-relative/index.less",
},
},
}
);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should not try to resolve CSS imports with URLs", async () => {
const testId = "./import-url.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
// it('should delegate resolving (LESS) imports with URLs to "less" package', async () => {
// const testId = "./import-keyword-url.less";
// const compiler = getCompiler(testId);
// const stats = await compile(compiler);
// const codeFromBundle = getCodeFromBundle(stats, compiler);
// const codeFromLess = await getCodeFromLess(testId);
//
// expect(codeFromBundle.css).toBe(codeFromLess.css);
// expect(codeFromBundle.css).toMatchSnapshot("css");
// expect(getWarnings(stats)).toMatchSnapshot("warnings");
// expect(getErrors(stats)).toMatchSnapshot("errors");
// });
it("should allow to import non-less files", async () => {
const testId = "./import-non-less.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should provide a useful error message if the import could not be found", async () => {
const testId = "./error-import-not-existing.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should provide a useful error message if there was a syntax error", async () => {
const testId = "./error-syntax.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should be able to import a file with an absolute path", async () => {
const importedFilePath = path.resolve(
__dirname,
"fixtures",
"import-absolute-target.less"
);
const testId = "./import-absolute.less";
const compiler = getCompiler(testId, {
lessOptions: {
globalVars: {
absolutePath: `'${importedFilePath}'`,
},
},
});
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should add all resolved imports as dependencies", async () => {
const testId = "./import.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const { fileDependencies } = stats.compilation;
validateDependencies(fileDependencies);
const fixtures = [
path.resolve(__dirname, "fixtures", "import.less"),
path.resolve(__dirname, "fixtures", "css.css"),
path.resolve(__dirname, "fixtures", "basic.less"),
];
fixtures.forEach((fixture) => {
expect(fileDependencies.has(fixture)).toBe(true);
});
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should add all resolved imports as dependencies, including aliased ones", async () => {
const testId = "./import-webpack-alias.less";
const compiler = getCompiler(
testId,
{},
{
resolve: {
alias: {
"aliased-some": "some",
},
},
}
);
const stats = await compile(compiler);
const { fileDependencies } = stats.compilation;
validateDependencies(fileDependencies);
const fixtures = [
path.resolve(__dirname, "fixtures", "import-webpack-alias.less"),
path.resolve(
__dirname,
"fixtures",
"node_modules",
"some",
"module.less"
),
];
fixtures.forEach((fixture) => {
expect(fileDependencies.has(fixture)).toBe(true);
});
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should add all resolved imports as dependencies, including those from the Less resolver", async () => {
const testId = "./import-dependency.less";
const compiler = getCompiler(testId, {
lessOptions: {
paths: [__dirname, nodeModulesPath],
},
});
const stats = await compile(compiler);
const { fileDependencies } = stats.compilation;
validateDependencies(fileDependencies);
const fixtures = [
path.resolve(__dirname, "fixtures", "import-dependency.less"),
path.resolve(
__dirname,
"fixtures",
"node_modules",
"some",
"module.less"
),
];
fixtures.forEach((fixture) => {
expect(fileDependencies.has(fixture)).toBe(true);
});
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should add a file with an error as dependency so that the watcher is triggered when the error is fixed", async () => {
const testId = "./error-import-file-with-error.less";
const compiler = getCompiler(testId, {
lessOptions: {
paths: [__dirname, nodeModulesPath],
},
});
const stats = await compile(compiler);
const { fileDependencies } = stats.compilation;
validateDependencies(fileDependencies);
const fixtures = [
path.resolve(__dirname, "fixtures", "error-import-file-with-error.less"),
path.resolve(__dirname, "fixtures", "error-syntax.less"),
];
fixtures.forEach((fixture) => {
expect(fileDependencies.has(fixture)).toBe(true);
});
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should add all resolved imports as dependencies, including node_modules", async () => {
const testId = "./import-webpack.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const { fileDependencies } = stats.compilation;
validateDependencies(fileDependencies);
const fixtures = [
path.resolve(__dirname, "fixtures", "import-webpack.less"),
path.resolve(
__dirname,
"fixtures",
"node_modules",
"some",
"module.less"
),
];
fixtures.forEach((fixture) => {
expect(fileDependencies.has(fixture)).toBe(true);
});
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should watch imports correctly", async () => {
const testId = "./watch.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
const { fileDependencies } = stats.compilation;
validateDependencies(fileDependencies);
const fixtures = [
path.resolve(__dirname, "fixtures", "watch.less"),
path.resolve(
__dirname,
"fixtures",
"node_modules",
"package",
"style.less"
),
];
fixtures.forEach((fixture) => {
expect(fileDependencies.has(fixture)).toBe(true);
});
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should get absolute path relative rootContext", async () => {
const testId = "./import-absolute-2.less";
const compiler = getCompiler(
testId,
{},
{
context: path.resolve(__dirname),
entry: path.resolve(__dirname, "./fixtures", testId),
}
);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should resolve unresolved url with alias", async () => {
const testId = "./import-absolute-3.less";
const compiler = getCompiler(
testId,
{},
{
resolve: {
alias: {
"/styles/style.less": path.resolve(
__dirname,
"fixtures",
"basic.less"
),
},
},
}
);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should resolve absolute path", async () => {
// Create the file with absolute path
const file = path.resolve(__dirname, "fixtures", "generated-1.less");
const absolutePath = path.resolve(__dirname, "fixtures", "basic.less");
fs.writeFileSync(file, `@import "${absolutePath}";`);
const testId = "./generated-1.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should resolve absolute path with alias", async () => {
// Create the file with absolute path
const file = path.resolve(__dirname, "fixtures", "generated-2.less");
const absolutePath = path.resolve(__dirname, "fixtures", "unresolved.less");
fs.writeFileSync(file, `@import "${absolutePath}";`);
const config = {};
config.resolve = {};
config.resolve.alias = {};
config.resolve.alias[absolutePath] = path.resolve(
__dirname,
"fixtures",
"basic.less"
);
const testId = "./generated-2.less";
const compiler = getCompiler(testId, {}, config);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should resolve non-less import with alias", async () => {
const testId = "./import-non-less-2.less";
const compiler = getCompiler(
testId,
{},
{
resolve: {
alias: {
"../../some.file": path.resolve(
__dirname,
"fixtures",
"folder",
"some.file"
),
},
},
}
);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
// it("should not add to dependencies imports with URLs", async () => {
// const testId = "./import-url-deps.less";
// const compiler = getCompiler(testId);
// const stats = await compile(compiler);
// const codeFromBundle = getCodeFromBundle(stats, compiler);
// const codeFromLess = await getCodeFromLess(testId);
// const { fileDependencies } = stats.compilation;
//
// validateDependencies(fileDependencies);
//
// Array.from(fileDependencies).forEach((item) => {
// ["http", "https"].forEach((protocol) => {
// expect(item.includes(protocol)).toBe(false);
// });
// });
//
// expect(codeFromBundle.css).toBe(codeFromLess.css);
// expect(codeFromBundle.css).toMatchSnapshot("css");
// expect(getWarnings(stats)).toMatchSnapshot("warnings");
// expect(getErrors(stats)).toMatchSnapshot("errors");
// });
it("should add path to dependencies", async () => {
// Create the file with absolute path
const file = path.resolve(__dirname, "fixtures", "generated-3.less");
const absolutePath = path.resolve(__dirname, "fixtures", "basic.less");
fs.writeFileSync(file, `@import "${absolutePath}";`);
const testId = "./generated-3.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const { fileDependencies } = stats.compilation;
validateDependencies(fileDependencies);
let isAddedToDependensies = false;
Array.from(fileDependencies).forEach((item) => {
if (item === absolutePath) {
isAddedToDependensies = true;
}
});
expect(isAddedToDependensies).toBe(true);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it('should resolve the "less" field from the "exports" field from "package.json"', async () => {
const testId = "./import-package-with-exports.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it('should resolve "@import" without "less" extension', async () => {
const testId = "./import-without-extension.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it('should resolve "@import" with "less" extension', async () => {
const testId = "./import-without-extension.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it('should resolve "@import" with "css" extension', async () => {
const testId = "./import-with-css-extension.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it('should resolve "@import" with "php" extension', async () => {
const testId = "./import-with-php-extension.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should work and have loaderContext in less plugins", async () => {
let contextInClass = false;
let contextInObject = false;
// eslint-disable-next-line global-require
class Plugin extends require("less").FileManager {
constructor(less, pluginManager) {
super();
if (typeof pluginManager.webpackLoaderContext !== "undefined") {
contextInClass = true;
}
}
}
class CustomClassPlugin {
// eslint-disable-next-line class-methods-use-this
install(less, pluginManager) {
pluginManager.addFileManager(new Plugin(less, pluginManager));
}
}
const customObjectPlugin = {
install(less, packageManager) {
if (typeof packageManager.webpackLoaderContext !== "undefined") {
contextInObject = true;
}
},
};
const testId = "./basic-plugins-2.less";
const compiler = getCompiler(testId, {
lessOptions: {
plugins: [new CustomClassPlugin(), customObjectPlugin],
},
});
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
expect(contextInClass).toBe(true);
expect(contextInObject).toBe(true);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
// TODO bug on windows
it.skip("should work with circular imports", async () => {
const testId = "./circular.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should work and respect the 'resolve.byDependecy.less' option", async () => {
const testId = "./by-dependency.less";
const compiler = getCompiler(
testId,
{},
{
resolve: {
byDependency: {
less: {
mainFiles: ["custom"],
},
},
},
}
);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should import from glob expressions", async () => {
const testId = "./glob.less";
const compiler = getCompiler(testId, {
lessOptions: {
plugins: [lessPluginGlob],
},
});
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId, {
lessOptions: {
plugins: [lessPluginGlob],
},
});
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should emit an error", async () => {
const testId = "./error.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it("should work and logging", async () => {
const testId = "./logging.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
const logs = [];
for (const [name, value] of stats.compilation.logging) {
if (/less-loader/.test(name)) {
logs.push(
value.map((item) => {
return {
type: item.type,
args: item.args,
};
})
);
}
}
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(logs).toMatchSnapshot("logs");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it(`should work with a package with "sass" and "exports" fields and a custom condition (theme1)`, async () => {
const testId = "./import-package-with-exports-and-custom-condition.less";
const compiler = getCompiler(
testId,
{},
{
resolve: {
conditionNames: ["theme1", "..."],
},
}
);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(
testId,
{},
{
packageExportsCustomConditionTestVariant: 1,
}
);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it(`should work with a package with "sass" and "exports" fields and a custom condition (theme2)`, async () => {
const testId = "./import-package-with-exports-and-custom-condition.less";
const compiler = getCompiler(
testId,
{},
{
resolve: {
conditionNames: ["theme2", "..."],
},
}
);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(
testId,
{},
{
packageExportsCustomConditionTestVariant: 2,
}
);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
});
less-loader-11.1.0/test/sourceMap-options.test.js 0000664 0000000 0000000 00000014612 14317644650 0021744 0 ustar 00root root 0000000 0000000 import path from "path";
import fs from "fs";
import {
compile,
getCodeFromBundle,
getCodeFromLess,
getCompiler,
getErrors,
getWarnings,
} from "./helpers";
describe('"sourceMap" options', () => {
it('should generate source maps when value is "true"', async () => {
const testId = "./source-map.less";
const compiler = getCompiler(testId, {
sourceMap: true,
});
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
const { css, map } = codeFromBundle;
map.sourceRoot = "";
map.sources = map.sources.map((source) => {
expect(path.isAbsolute(source)).toBe(true);
expect(source).toBe(path.normalize(source));
expect(fs.existsSync(path.resolve(map.sourceRoot, source))).toBe(true);
return path
.relative(path.resolve(__dirname, ".."), source)
.replace(/\\/g, "/");
});
expect(css).toBe(codeFromLess.css);
expect(css).toMatchSnapshot("css");
expect(map).toMatchSnapshot("source map");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it('should generate source maps when the "devtool" value is "source-map"', async () => {
const testId = "./source-map.less";
const compiler = getCompiler(
testId,
{},
{
devtool: "source-map",
}
);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
const { css, map } = codeFromBundle;
map.sourceRoot = "";
map.sources = map.sources.map((source) => {
expect(path.isAbsolute(source)).toBe(true);
expect(source).toBe(path.normalize(source));
expect(fs.existsSync(path.resolve(map.sourceRoot, source))).toBe(true);
return path
.relative(path.resolve(__dirname, ".."), source)
.replace(/\\/g, "/");
});
expect(css).toBe(codeFromLess.css);
expect(css).toMatchSnapshot("css");
expect(map).toMatchSnapshot("source map");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it('should generate source maps when value is "true" and the "devtool" value is "false"', async () => {
const testId = "./source-map.less";
const compiler = getCompiler(
testId,
{
sourceMap: true,
},
{
devtool: false,
}
);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
const { css, map } = codeFromBundle;
map.sourceRoot = "";
map.sources = map.sources.map((source) => {
expect(path.isAbsolute(source)).toBe(true);
expect(source).toBe(path.normalize(source));
expect(fs.existsSync(path.resolve(map.sourceRoot, source))).toBe(true);
return path
.relative(path.resolve(__dirname, ".."), source)
.replace(/\\/g, "/");
});
expect(css).toBe(codeFromLess.css);
expect(css).toMatchSnapshot("css");
expect(map).toMatchSnapshot("source map");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it('should generate source maps when value has "false" value, but the "lessOptions.sourceMap.outputSourceFiles" is "true"', async () => {
const testId = "./source-map.less";
const compiler = getCompiler(testId, {
sourceMap: false,
lessOptions: {
sourceMap: { outputSourceFiles: true },
},
});
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
const { css, map } = codeFromBundle;
map.sourceRoot = "";
map.sources = map.sources.map((source) => {
expect(path.isAbsolute(source)).toBe(true);
expect(fs.existsSync(path.resolve(map.sourceRoot, source))).toBe(true);
return path
.relative(path.resolve(__dirname, ".."), source)
.replace(/\\/g, "/");
});
expect(css).toBe(codeFromLess.css);
expect(css).toMatchSnapshot("css");
expect(map).toMatchSnapshot("source map");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it('should not generate source maps when value is "false"', async () => {
const testId = "./source-map.less";
const compiler = getCompiler(testId, {
sourceMap: false,
});
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
const { css, map } = codeFromBundle;
expect(css).toBe(codeFromLess.css);
expect(css).toMatchSnapshot("css");
expect(map).toBeUndefined();
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it('should not generate source maps when the "devtool" value is "false"', async () => {
const testId = "./source-map.less";
const compiler = getCompiler(
testId,
{},
{
devtool: false,
}
);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
const { css, map } = codeFromBundle;
expect(css).toBe(codeFromLess.css);
expect(css).toMatchSnapshot("css");
expect(map).toBeUndefined();
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it('should not generate source maps when value is "false" and the "devtool" value is "source-map"', async () => {
const testId = "./source-map.less";
const compiler = getCompiler(
testId,
{
sourceMap: false,
},
{
devtool: "source-map",
}
);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
const { css, map } = codeFromBundle;
expect(css).toBe(codeFromLess.css);
expect(css).toMatchSnapshot("css");
expect(map).toBeUndefined();
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
});
less-loader-11.1.0/test/validate-options.test.js 0000664 0000000 0000000 00000004150 14317644650 0021573 0 ustar 00root root 0000000 0000000 import { getCompiler, compile } from "./helpers/index";
describe("validate options", () => {
const tests = {
lessOptions: {
success: [
{ strictMath: true },
() => {
return {
strictMath: true,
};
},
],
failure: [1, true, false, "test", []],
},
additionalData: {
success: ["@background: coral;", () => "@background: coral;"],
failure: [1, true, false, /test/, [], {}],
},
sourceMap: {
success: [true, false],
failure: ["string"],
},
webpackImporter: {
success: [true, false],
failure: ["string"],
},
implementation: {
// eslint-disable-next-line global-require
success: [require("less"), "less"],
failure: [true, false, () => {}, []],
},
unknown: {
success: [],
failure: [1, true, false, "test", /test/, [], {}, { foo: "bar" }],
},
};
function stringifyValue(value) {
if (
Array.isArray(value) ||
(value && typeof value === "object" && value.constructor === Object)
) {
return JSON.stringify(value);
}
return value;
}
async function createTestCase(key, value, type) {
it(`should ${
type === "success" ? "successfully validate" : "throw an error on"
} the "${key}" option with "${stringifyValue(value)}" value`, async () => {
const compiler = getCompiler("./basic.less", {
[key]: value,
});
let stats;
try {
stats = await compile(compiler);
} finally {
if (type === "success") {
expect(stats.hasErrors()).toBe(false);
} else if (type === "failure") {
const {
compilation: { errors },
} = stats;
expect(errors).toHaveLength(1);
expect(() => {
throw new Error(errors[0].error.message);
}).toThrowErrorMatchingSnapshot();
}
}
});
}
for (const [key, values] of Object.entries(tests)) {
for (const type of Object.keys(values)) {
for (const value of values[type]) {
createTestCase(key, value, type);
}
}
}
});
less-loader-11.1.0/test/webpackImporter-options.test.js 0000664 0000000 0000000 00000004272 14317644650 0023145 0 ustar 00root root 0000000 0000000 import {
compile,
getCodeFromBundle,
getCodeFromLess,
getCompiler,
getErrors,
getWarnings,
} from "./helpers";
describe('"webpackImporter" option', () => {
it("should work when value is not specify", async () => {
const testId = "./import-webpack.less";
const compiler = getCompiler(testId);
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it('should work when value is "true"', async () => {
const testId = "./import-webpack.less";
const compiler = getCompiler(testId, {
webpackImporter: true,
});
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it('should work when value is "false"', async () => {
const testId = "./import.less";
const compiler = getCompiler(testId, {
webpackImporter: false,
});
const stats = await compile(compiler);
const codeFromBundle = getCodeFromBundle(stats, compiler);
const codeFromLess = await getCodeFromLess(testId);
expect(codeFromBundle.css).toBe(codeFromLess.css);
expect(codeFromBundle.css).toMatchSnapshot("css");
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
it('should throw an error on webpack import when value is "false"', async () => {
const testId = "./import-webpack.less";
const compiler = getCompiler(testId, {
webpackImporter: false,
});
const stats = await compile(compiler);
expect(getWarnings(stats)).toMatchSnapshot("warnings");
expect(getErrors(stats)).toMatchSnapshot("errors");
});
});