├── .eslintignore
├── .npmignore
├── .gitignore
├── test
├── setup-jest.js
├── rules
│ ├── niqqud.test.js
│ ├── neutral.test.js
│ ├── separators.test.js
│ ├── boundaries.test.js
│ ├── beginnings.test.js
│ ├── brackets.test.js
│ ├── braces.test.js
│ ├── parenthesis.test.js
│ ├── predefined.test.js
│ ├── unchanged.test.js
│ └── endings.test.js
├── utils
│ └── finals.test.js
├── otf.test.js
├── ui
│ └── accessibility.test.js
├── attributes.test.js
└── dom.test.js
├── src
├── ui
│ ├── fonts
│ │ ├── ivritacons-alefalefalef.eot
│ │ ├── ivritacons-alefalefalef.otf
│ │ ├── ivritacons-alefalefalef.woff
│ │ └── ivritacons-alefalefalef.woff2
│ ├── hebrew.js
│ ├── index.js
│ ├── docReady.js
│ ├── switch.js
│ ├── custom.js
│ ├── default.js
│ └── style.scss
├── utils
│ ├── finals.js
│ └── characters.js
├── textNode.js
├── textAttribute.js
├── textObject.js
├── textElement.js
├── ivrita.js
├── rules.js
├── wordlists.js
└── element.js
├── .babelrc
├── .eslintrc.js
├── .github
└── workflows
│ ├── test.yml
│ └── deploy.yml
├── package.json
├── webpack.config.js
├── README.md
└── LICENSE
/.eslintignore:
--------------------------------------------------------------------------------
1 | dist
2 |
--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | .github
2 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | coverage
2 | dist
3 | node_modules
4 |
--------------------------------------------------------------------------------
/test/setup-jest.js:
--------------------------------------------------------------------------------
1 | import jQuery from 'jquery';
2 |
3 | import 'regenerator-runtime/runtime';
4 |
5 | global.jQuery = jQuery;
6 |
--------------------------------------------------------------------------------
/src/ui/fonts/ivritacons-alefalefalef.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AlefAlefAlef/ivrita/HEAD/src/ui/fonts/ivritacons-alefalefalef.eot
--------------------------------------------------------------------------------
/src/ui/fonts/ivritacons-alefalefalef.otf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AlefAlefAlef/ivrita/HEAD/src/ui/fonts/ivritacons-alefalefalef.otf
--------------------------------------------------------------------------------
/src/ui/fonts/ivritacons-alefalefalef.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AlefAlefAlef/ivrita/HEAD/src/ui/fonts/ivritacons-alefalefalef.woff
--------------------------------------------------------------------------------
/src/ui/fonts/ivritacons-alefalefalef.woff2:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AlefAlefAlef/ivrita/HEAD/src/ui/fonts/ivritacons-alefalefalef.woff2
--------------------------------------------------------------------------------
/test/rules/niqqud.test.js:
--------------------------------------------------------------------------------
1 | import { genderize, FEMALE } from '../../src/ivrita';
2 |
3 | test('Skip niqqud words', () => {
4 | expect(genderize('מעצּבֻּ/תֻ', FEMALE)).toBe('מעצּבֻּ/תֻ');
5 | });
6 |
--------------------------------------------------------------------------------
/test/rules/neutral.test.js:
--------------------------------------------------------------------------------
1 | import { genderize, NEUTRAL } from '../../src/ivrita';
2 |
3 | test('No multiple slashes on neutral', () => {
4 | expect(genderize('הקלד/י', NEUTRAL)).toBe('הקלד/י'); // unchanged
5 | });
6 |
--------------------------------------------------------------------------------
/test/rules/separators.test.js:
--------------------------------------------------------------------------------
1 | import { genderize, MALE } from '../../src/ivrita';
2 |
3 | test('All separators', () => {
4 | expect(genderize('את/ה', MALE)).toBe('אתה');
5 | expect(genderize('את.ה', MALE)).toBe('אתה');
6 | expect(genderize('את\\ה', MALE)).toBe('אתה');
7 | });
8 |
--------------------------------------------------------------------------------
/src/ui/hebrew.js:
--------------------------------------------------------------------------------
1 | export const iconTitle = 'עבריתה';
2 | export const aboutLinkText = 'אודות מיזם עבריתה';
3 | export const defaultMaleLabel = 'איש';
4 | export const defaultFemaleLabel = 'אישה';
5 | export const defaultNeutralLabel = 'ניטרלי';
6 | export const ariaLabel = 'שינוי לשון הפנייה של האתר ל%s';
7 |
--------------------------------------------------------------------------------
/.babelrc:
--------------------------------------------------------------------------------
1 | {
2 | "presets": [
3 | "@babel/preset-env"
4 | ],
5 | "plugins": [
6 | ["@babel/plugin-proposal-class-properties", {
7 | "loose": true
8 | }],
9 | ["@babel/plugin-transform-template-literals", {
10 | "loose": true
11 | }],
12 | ["@babel/plugin-transform-react-jsx", { "pragma": "dom" }]
13 | ]
14 | }
--------------------------------------------------------------------------------
/src/utils/finals.js:
--------------------------------------------------------------------------------
1 | /* eslint-disable quote-props */
2 | export const fins = {
3 | 'ן': 'נ',
4 | 'ף': 'פ',
5 | 'ך': 'כ',
6 | 'ם': 'מ',
7 | 'ץ': 'צ',
8 | };
9 | /* eslint-enable quote-props */
10 | export const finnables = Object.keys(fins).concat(Object.values(fins));
11 | export const finals = Object.keys(fins);
12 |
13 | export const toFin = (notFin) => Object.keys(fins).find((key) => fins[key] === notFin) || notFin;
14 | export const toNotFin = (fin) => (fins[fin] || fin);
15 |
--------------------------------------------------------------------------------
/src/ui/index.js:
--------------------------------------------------------------------------------
1 | import Ivrita from '../element';
2 | import CustomSwitch from './custom';
3 | import DefaultSwitch from './default';
4 |
5 | import DocReady from './docReady';
6 |
7 | const defaultSwitch = new DefaultSwitch();
8 |
9 | export const initDefaultSwitch = () => {
10 | window._ivrita = new Ivrita();
11 | defaultSwitch.setIvritaInstances(window._ivrita);
12 | defaultSwitch.init();
13 | };
14 |
15 | if (typeof document !== 'undefined') {
16 | DocReady(initDefaultSwitch);
17 | }
18 |
19 | defaultSwitch.custom = CustomSwitch;
20 | export default defaultSwitch;
21 |
--------------------------------------------------------------------------------
/src/textNode.js:
--------------------------------------------------------------------------------
1 | import TextObject, { IncompatibleTypeError } from './textObject';
2 |
3 | export default class TextNode extends TextObject {
4 | node = {};
5 |
6 | constructor(node) {
7 | if (!node) return false;
8 | if (!(node instanceof Text)) {
9 | throw IncompatibleTypeError;
10 | }
11 |
12 | super(node);
13 |
14 | this.node = node;
15 |
16 | if (!this.currentMode) {
17 | this.init();
18 | }
19 | }
20 |
21 | getValue() {
22 | return this.node.data;
23 | }
24 |
25 | setValue(newVal) {
26 | this.node.data = newVal;
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/src/textAttribute.js:
--------------------------------------------------------------------------------
1 | import TextObject, { IncompatibleTypeError } from './textObject';
2 |
3 | export default class TextAttribute extends TextObject {
4 | attr = {};
5 |
6 | constructor(attr) {
7 | if (!attr) return false;
8 | if (!(attr instanceof Attr)) {
9 | throw IncompatibleTypeError;
10 | }
11 |
12 | super(attr);
13 |
14 | this.attr = attr;
15 |
16 | if (!this.currentMode) {
17 | this.init();
18 | }
19 | }
20 |
21 | getValue() {
22 | return this.attr.value;
23 | }
24 |
25 | setValue(newVal) {
26 | this.attr.value = newVal;
27 | }
28 | }
29 |
--------------------------------------------------------------------------------
/.eslintrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 | parser: 'babel-eslint',
3 | plugins: ['jest'],
4 | env: {
5 | browser: true,
6 | es2021: true,
7 | 'jest/globals': true,
8 | },
9 | extends: ['airbnb-base'],
10 | parserOptions: {
11 | ecmaVersion: 12,
12 | sourceType: 'module',
13 | ecmaFeatures: {
14 | jsx: true,
15 | },
16 | },
17 | globals: {
18 | jQuery: true,
19 | },
20 | rules: {
21 | 'no-param-reassign': [2, { props: false }],
22 | 'no-new': [0],
23 | 'no-underscore-dangle': 0,
24 | 'import/no-extraneous-dependencies': ['error', { devDependencies: ['**/setup-jest.js'] }], // Allow importing jQuery in Jest setup file
25 | },
26 | };
27 |
--------------------------------------------------------------------------------
/test/rules/boundaries.test.js:
--------------------------------------------------------------------------------
1 | import { genderize, FEMALE, MALE } from '../../src/ivrita';
2 |
3 | test('Word ending with special chars', () => {
4 | expect(genderize('בוא/י"', FEMALE)).toBe('בואי"');
5 | expect(genderize('בוא/י"', MALE)).toBe('בוא"');
6 |
7 | expect(genderize('מרגיש/ה?', FEMALE)).toBe('מרגישה?');
8 | expect(genderize('מרגיש/ה?', MALE)).toBe('מרגיש?');
9 | });
10 |
11 | test('Word beginning with special chars', () => {
12 | expect(genderize('"בוא/י', FEMALE)).toBe('"בואי');
13 | expect(genderize('"בוא/י', MALE)).toBe('"בוא');
14 | });
15 |
16 | test('Rules beginning with boundary', () => {
17 | expect(genderize('י/תכתוב י/תרצה', MALE)).toBe('יכתוב ירצה');
18 |
19 | expect(genderize('ישראלים/ות סטודנטים/ות', FEMALE)).toBe('ישראליות סטודנטיות');
20 | });
21 |
--------------------------------------------------------------------------------
/src/ui/docReady.js:
--------------------------------------------------------------------------------
1 | // Based on https://github.com/nickeljew/es6-docready
2 |
3 | export default (callback) => {
4 | function completed() {
5 | document.removeEventListener('DOMContentLoaded', completed, false);
6 | window.removeEventListener('load', completed, false);
7 | callback();
8 | }
9 |
10 | // Events.on(document, 'DOMContentLoaded', completed)
11 |
12 | if (document.readyState === 'complete') {
13 | // Handle it asynchronously to allow scripts the opportunity to delay ready
14 | setTimeout(callback);
15 | } else {
16 | // Use the handy event callback
17 | document.addEventListener('DOMContentLoaded', completed, false);
18 |
19 | // A fallback to window.onload, that will always work
20 | window.addEventListener('load', completed, false);
21 | }
22 | };
23 |
--------------------------------------------------------------------------------
/src/utils/characters.js:
--------------------------------------------------------------------------------
1 | import { finals } from './finals';
2 |
3 | export const SEP = '[\\\\/.]';
4 | export const HEB = '[א-ת]';
5 | export const EXTSEP = '[\\\\./—־-]';
6 | export const G = '\'"”׳״'; // "Gershayim"
7 | export const MAKAF = '—־-';
8 | export const W = `[א-ת${G}]`;
9 | export const FIN = `[${finals}]`;
10 |
11 | const b = '^|$|\b|[^א-ת\u0590-\u05BD\u05BF\u05C1-\u05C2\u05C4-\u05C7\u05EF-\u05F2\uFB2A-\uFB4F]'; // Boundary, like "\b" in regex. All unicode characters which can be part of a hebrew word
12 | export const B = `(?=${b})`; // Look-ahead positive
13 | export const CB = `(${b})`; // Just capturing
14 | export const LBPB = `(?<=${b})`; // Look-behind positive - not used since it's not supported by Safari :(
15 | export const NCB = `(?:${b})`; // Non-capturing
16 |
17 | export const SYNTAX = [EXTSEP, '\\[', '\\{', '\\(', 'םן', 'ןם', 'יםות', 'ותים'].join('|');
18 |
--------------------------------------------------------------------------------
/.github/workflows/test.yml:
--------------------------------------------------------------------------------
1 | # This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
2 | # For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
3 |
4 | name: Tests and Linting
5 |
6 | on:
7 | push:
8 | branches: [ main ]
9 | pull_request:
10 | branches: [ main ]
11 |
12 | jobs:
13 | test:
14 |
15 | runs-on: ubuntu-latest
16 |
17 | steps:
18 | - uses: actions/checkout@v2
19 | - name: Use Node.js 14.x
20 | uses: actions/setup-node@v1
21 | with:
22 | node-version: 14.x
23 | - run: npm ci
24 | - run: npm test
25 |
26 | lint:
27 |
28 | runs-on: ubuntu-latest
29 |
30 | steps:
31 | - uses: actions/checkout@v2
32 | - name: Use Node.js 14.x
33 | uses: actions/setup-node@v1
34 | with:
35 | node-version: 14.x
36 | - run: npm ci
37 | - run: npx eslint .
--------------------------------------------------------------------------------
/test/rules/beginnings.test.js:
--------------------------------------------------------------------------------
1 | import { genderize, FEMALE, MALE } from '../../src/ivrita';
2 |
3 | test('Word beginnings', () => {
4 | expect(genderize('י/תכתוב', FEMALE)).toBe('תכתוב');
5 | expect(genderize('י/תכתוב', MALE)).toBe('יכתוב');
6 | expect(genderize('שי/תכתוב', FEMALE)).toBe('שתכתוב');
7 | expect(genderize('שי/תכתוב', MALE)).toBe('שיכתוב');
8 |
9 | expect(genderize('ת/יכתוב', FEMALE)).toBe('תכתוב');
10 | expect(genderize('ת/יכתוב', MALE)).toBe('יכתוב');
11 | expect(genderize('שת/יכתוב', FEMALE)).toBe('שתכתוב');
12 | expect(genderize('שת/יכתוב', MALE)).toBe('שיכתוב');
13 |
14 | expect(genderize('ת/ירצה', FEMALE)).toBe('תרצה');
15 | expect(genderize('ת/ירצה', MALE)).toBe('ירצה');
16 | expect(genderize('י/תרצה', FEMALE)).toBe('תרצה');
17 | expect(genderize('י/תרצה', MALE)).toBe('ירצה');
18 |
19 | expect(genderize('י/תבוא', FEMALE)).toBe('תבוא');
20 | expect(genderize('י/תבוא', MALE)).toBe('יבוא');
21 | expect(genderize('ת/יבוא', FEMALE)).toBe('תבוא');
22 | expect(genderize('ת/יבוא', MALE)).toBe('יבוא');
23 | });
24 |
--------------------------------------------------------------------------------
/test/rules/brackets.test.js:
--------------------------------------------------------------------------------
1 | import {
2 | genderize, FEMALE, MALE, NEUTRAL,
3 | } from '../../src/ivrita';
4 |
5 | test('Two parameters', () => {
6 | expect(genderize('[בן|בת]', FEMALE)).toBe('בת');
7 | expect(genderize('[בן|בת]', MALE)).toBe('בן');
8 |
9 | expect(genderize('[נאה|יפה]', FEMALE)).toBe('יפה');
10 | expect(genderize('[נאה|יפה]', MALE)).toBe('נאה');
11 |
12 | expect(genderize('[חתיך|מהממת]', FEMALE)).toBe('מהממת');
13 | expect(genderize('[חתיך|מהממת]', MALE)).toBe('חתיך');
14 | });
15 |
16 | test('Two parameters neutral', () => {
17 | expect(genderize('[בן|בת]', NEUTRAL)).toBe('בן/בת');
18 | });
19 |
20 | test('Three parameters', () => {
21 | expect(genderize('[בן|בת|ילד]', FEMALE)).toBe('בת');
22 | expect(genderize('[בן|בת|ילד]', MALE)).toBe('בן');
23 | expect(genderize('[בן|בת|ילד]', NEUTRAL)).toBe('ילד');
24 | });
25 |
26 | test('Partial options', () => {
27 | expect(genderize('תוכל[|י|ו]', FEMALE)).toBe('תוכלי');
28 | expect(genderize('תוכל[|י|ו]', MALE)).toBe('תוכל');
29 | expect(genderize('תוכל[|י|ו]', NEUTRAL)).toBe('תוכלו');
30 | });
31 |
--------------------------------------------------------------------------------
/src/ui/switch.js:
--------------------------------------------------------------------------------
1 | import JSXComponent from 'jsx-render/lib/JSXComponent';
2 |
3 | export default class IvritaSwitch extends JSXComponent {
4 | /**
5 | * The name of the event to be dispatched on `document` before reading the configuration
6 | */
7 | static EVENT_INIT = 'ivrita-ui-ready';
8 |
9 | /**
10 | * @property {Ivrita[]} ivritaInstances
11 | */
12 | ivritaInstances = [];
13 |
14 | /**
15 | * @param {...Ivrita} ivritaInstances
16 | */
17 | constructor(...ivritaInstances) {
18 | super();
19 | if (ivritaInstances.length) {
20 | this.setIvritaInstances(...ivritaInstances);
21 | }
22 | }
23 |
24 | /**
25 | * @param {...Ivrita} ivritaInstances
26 | */
27 | setIvritaInstances(...ivritaInstances) {
28 | this.ivritaInstances = ivritaInstances;
29 | }
30 |
31 | /**
32 | * Sets the mode for all ivritaInstances of this switch
33 | * @param {string} modeStr The new mode
34 | */
35 | setMode(mode) {
36 | this.ivritaInstances.forEach((i) => i.setMode(mode));
37 | window.localStorage.setItem('ivrita-mode', mode);
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/src/textObject.js:
--------------------------------------------------------------------------------
1 | import { genderize, ORIGINAL } from './ivrita';
2 |
3 | export const IncompatibleTypeError = new Error('Incompatible node passed to the node constructor');
4 |
5 | export default class TextObject {
6 | originalText = '';
7 |
8 | currentMode = false;
9 |
10 | storedValues = {}
11 |
12 | static instances = new WeakMap();
13 |
14 | constructor(node) {
15 | if (TextObject.instances.has(node)) {
16 | return TextObject.instances.get(node);
17 | }
18 |
19 | TextObject.instances.set(node, this);
20 | }
21 |
22 | init() {
23 | this.originalText = this.getValue();
24 | }
25 |
26 | setMode(newMode) {
27 | let newVal;
28 | this.currentMode = newMode;
29 |
30 | if (this.storedValues[newMode] !== undefined) {
31 | newVal = this.storedValues[newMode];
32 | } else if (newMode === ORIGINAL) {
33 | newVal = this.originalText;
34 | } else {
35 | newVal = genderize(this.originalText, newMode);
36 | }
37 |
38 | if (newVal !== this.getValue()) {
39 | this.setValue(newVal);
40 | }
41 | }
42 |
43 | getValue() {
44 | return this.value;
45 | }
46 |
47 | setValue(newVal) {
48 | this.value = newVal;
49 | }
50 | }
51 |
--------------------------------------------------------------------------------
/src/textElement.js:
--------------------------------------------------------------------------------
1 | import TextObject, { IncompatibleTypeError } from './textObject';
2 | import { MALE, FEMALE, NEUTRAL } from './ivrita';
3 |
4 | export const MALE_DATA_ATTR = 'ivritaMale';
5 | export const FEMALE_DATA_ATTR = 'ivritaFemale';
6 | export const NEUTRAL_DATA_ATTR = 'ivritaNeutral';
7 |
8 | export default class TextElement extends TextObject {
9 | element = {};
10 |
11 | constructor(element) {
12 | if (!element) return false;
13 | if (!(element instanceof Element)) {
14 | throw IncompatibleTypeError;
15 | }
16 |
17 | super(element);
18 |
19 | this.element = element;
20 |
21 | if (!this.currentMode) {
22 | this.init();
23 | }
24 | }
25 |
26 | init() {
27 | super.init();
28 | if (this.element.dataset[MALE_DATA_ATTR]) {
29 | this.storedValues[MALE] = this.element.dataset[MALE_DATA_ATTR];
30 | }
31 | if (this.element.dataset[FEMALE_DATA_ATTR]) {
32 | this.storedValues[FEMALE] = this.element.dataset[FEMALE_DATA_ATTR];
33 | }
34 | if (this.element.dataset[NEUTRAL_DATA_ATTR]) {
35 | this.storedValues[NEUTRAL] = this.element.dataset[NEUTRAL_DATA_ATTR];
36 | }
37 | }
38 |
39 | getValue() {
40 | return this.element.innerHTML;
41 | }
42 |
43 | setValue(newVal) {
44 | this.element.innerHTML = newVal;
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/test/utils/finals.test.js:
--------------------------------------------------------------------------------
1 | import {
2 | finnables, toFin, toNotFin,
3 | } from '../../src/utils/finals';
4 |
5 | test('Finnables helper', () => {
6 | expect(finnables).toContain('ם');
7 | expect(finnables).toContain('מ');
8 | expect(finnables).toContain('ן');
9 | expect(finnables).toContain('ץ');
10 | expect(finnables).toContain('כ');
11 |
12 | expect(finnables).not.toContain('ד');
13 | expect(finnables).not.toContain('5');
14 | expect(finnables).not.toContain('j');
15 | });
16 |
17 | test('toFin helper', () => {
18 | expect(toFin('מ')).toEqual('ם');
19 | expect(toFin('נ')).toEqual('ן');
20 | expect(toFin('צ')).toEqual('ץ');
21 | expect(toFin('כ')).toEqual('ך');
22 |
23 | expect(toFin('ץ')).toEqual('ץ');
24 | expect(toFin('ם')).toEqual('ם');
25 |
26 | expect(toFin('י')).toEqual('י');
27 | expect(toFin('8')).toEqual('8');
28 | expect(toFin('h')).toEqual('h');
29 | });
30 |
31 | test('toNotFin helper', () => {
32 | expect(toNotFin('ם')).toEqual('מ');
33 | expect(toNotFin('ן')).toEqual('נ');
34 | expect(toNotFin('ץ')).toEqual('צ');
35 | expect(toNotFin('ך')).toEqual('כ');
36 |
37 | expect(toNotFin('צ')).toEqual('צ');
38 | expect(toNotFin('מ')).toEqual('מ');
39 |
40 | expect(toNotFin('י')).toEqual('י');
41 | expect(toNotFin('8')).toEqual('8');
42 | expect(toNotFin('h')).toEqual('h');
43 | });
44 |
--------------------------------------------------------------------------------
/test/rules/braces.test.js:
--------------------------------------------------------------------------------
1 | import { genderize, FEMALE, MALE } from '../../src/ivrita';
2 |
3 | test('Basic braces functionality', () => {
4 | expect(genderize('{רוצים/ות}', FEMALE)).toBe('רוצים/ות');
5 | expect(genderize('{רוצים/ות}', MALE)).toBe('רוצים/ות');
6 |
7 | expect(genderize('{הרבה מעצבים/ות רוצים/ות ללמוד תכנות}', FEMALE)).toBe('הרבה מעצבים/ות רוצים/ות ללמוד תכנות');
8 | expect(genderize('{הרבה מעצבים/ות רוצים/ות ללמוד תכנות}', MALE)).toBe('הרבה מעצבים/ות רוצים/ות ללמוד תכנות');
9 | });
10 |
11 | test('Braces mixed in a sentence', () => {
12 | expect(genderize('הרבה מעצבים/ות {רוצים/ות} למצוא את עצמם/ן', FEMALE)).toBe('הרבה מעצבות רוצים/ות למצוא את עצמן');
13 | expect(genderize('הרבה מעצבים/ות {רוצים/ות} למצוא את עצמם/ן', MALE)).toBe('הרבה מעצבים רוצים/ות למצוא את עצמם');
14 |
15 | expect(genderize('הרבה {מעצבים/ות} רוצים/ות לראות את {עצמם/ן} כאילו הם/ן יצאו ממצריים כגבר/אישה {חזק.ה} ועצמאי.ת', FEMALE)).toBe('הרבה מעצבים/ות רוצות לראות את עצמם/ן כאילו הן יצאו ממצריים כאישה חזק.ה ועצמאית');
16 | expect(genderize('הרבה {מעצבים/ות} רוצים/ות לראות את {עצמם/ן} כאילו הם/ן יצאו ממצריים כגבר/אישה {חזק.ה} ועצמאי.ת', MALE)).toBe('הרבה מעצבים/ות רוצים לראות את עצמם/ן כאילו הם יצאו ממצריים כגבר חזק.ה ועצמאי');
17 | });
18 |
19 | test('Brackets inside braces', () => {
20 | expect(genderize('{[בן|בת]}', FEMALE)).toBe('[בן|בת]');
21 | expect(genderize('{[בן|בת]}', MALE)).toBe('[בן|בת]');
22 | });
23 |
--------------------------------------------------------------------------------
/test/otf.test.js:
--------------------------------------------------------------------------------
1 | import Ivrita from '../src/element';
2 |
3 | test('setFontFeatureSettings on clean element', () => {
4 | const el = document.createElement('p');
5 |
6 | expect(el.style.fontFeatureSettings).toEqual('');
7 |
8 | const ivrita = new Ivrita(el);
9 |
10 | ivrita.setFontFeatureSettings(true);
11 |
12 | expect(el.style.fontFeatureSettings).toEqual('"titl"');
13 |
14 | ivrita.setFontFeatureSettings(false);
15 |
16 | expect(el.style.fontFeatureSettings).toEqual('normal');
17 | });
18 |
19 | test('OpenType setting on element with pre-existing settings', () => {
20 | const el = document.createElement('p');
21 |
22 | el.style.fontFeatureSettings = '"ss01" 1, "tnum"';
23 |
24 | const ivrita = new Ivrita(el);
25 |
26 | ivrita.setFontFeatureSettings(true);
27 |
28 | expect(el.style.fontFeatureSettings).toEqual('"ss01" 1, "tnum", "titl"');
29 |
30 | ivrita.setFontFeatureSettings(false);
31 |
32 | expect(el.style.fontFeatureSettings).toEqual('"ss01" 1, "tnum"');
33 | });
34 |
35 | test('setFontFeatureSettings on clean element', () => {
36 | const el = document.createElement('p');
37 |
38 | expect(el.style.fontFeatureSettings).toEqual('');
39 |
40 | const ivrita = new Ivrita(el);
41 |
42 | ivrita.setMode(Ivrita.MULTI);
43 |
44 | expect(el.style.fontFeatureSettings).toEqual('"titl"');
45 |
46 | ivrita.setMode(Ivrita.NEUTRAL);
47 |
48 | expect(el.style.fontFeatureSettings).toEqual('normal');
49 | });
50 |
--------------------------------------------------------------------------------
/.github/workflows/deploy.yml:
--------------------------------------------------------------------------------
1 | # This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
2 | # For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
3 |
4 | name: Deploy to CDN
5 |
6 | on:
7 | push:
8 | branches: [ main ]
9 |
10 | jobs:
11 | build:
12 |
13 | runs-on: ubuntu-latest
14 |
15 | steps:
16 | - uses: actions/checkout@v2
17 | - name: Use Node.js 14.x
18 | uses: actions/setup-node@v1
19 | with:
20 | node-version: 14.x
21 | - run: npm ci
22 | - run: npm run build --if-present
23 | - run: npm test
24 |
25 | - name: Deploy to S3
26 | uses: jakejarvis/s3-sync-action@master
27 | with:
28 | args: --acl public-read --follow-symlinks --delete
29 | env:
30 | AWS_S3_BUCKET: ${{ secrets.AWS_S3_BUCKET }}
31 | AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
32 | AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
33 | AWS_REGION: 'eu-central-1'
34 | SOURCE_DIR: 'dist'
35 |
36 | - name: Invalidate CloudFront Cache
37 | uses: chetan/invalidate-cloudfront-action@master
38 | env:
39 | DISTRIBUTION: ${{ secrets.AWS_CLOUDFRONT_DISTRIBUTION }}
40 | PATHS: '/*'
41 | AWS_REGION: 'eu-central-1'
42 | AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
43 | AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
44 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "ivrita",
3 | "version": "1.0.1",
4 | "description": "Ivrita is an open-source set of typographic tools for gender equality in Hebrew",
5 | "main": "src/ivrita.js",
6 | "browser": "src/element.js",
7 | "directories": {
8 | "example": "examples"
9 | },
10 | "scripts": {
11 | "build": "webpack",
12 | "watch": "webpack --watch",
13 | "test": "jest",
14 | "test-watch": "jest --watch --notify"
15 | },
16 | "jest": {
17 | "setupFiles": [
18 | "./test/setup-jest.js"
19 | ]
20 | },
21 | "repository": {
22 | "type": "git",
23 | "url": "git+https://github.com/AlefAlefAlef/ivrita.git"
24 | },
25 | "author": "Reuven Karasik and Avraham Cornfeld",
26 | "license": "AGPL-3.0-or-later",
27 | "bugs": {
28 | "url": "https://github.com/AlefAlefAlef/ivrita/issues"
29 | },
30 | "homepage": "https://github.com/AlefAlefAlef/ivrita#readme",
31 | "dependencies": {
32 | "jsx-render": "^1.1.1"
33 | },
34 | "devDependencies": {
35 | "@babel/core": "^7.12.3",
36 | "@babel/plugin-proposal-class-properties": "^7.12.1",
37 | "@babel/plugin-syntax-jsx": "^7.12.1",
38 | "@babel/plugin-transform-react-jsx": "^7.12.12",
39 | "@babel/preset-env": "^7.12.1",
40 | "babel-cli": "^6.26.0",
41 | "babel-eslint": "^10.1.0",
42 | "babel-loader": "^8.1.0",
43 | "css-loader": "^5.0.1",
44 | "eslint": "^7.12.1",
45 | "eslint-config-airbnb-base": "^14.2.0",
46 | "eslint-plugin-import": "^2.22.1",
47 | "eslint-plugin-jest": "^24.1.0",
48 | "file-loader": "^6.2.0",
49 | "jest": "^26.6.1",
50 | "jest-cli": "^26.6.1",
51 | "jquery": "^3.5.1",
52 | "regenerator-runtime": "^0.11.1",
53 | "sass": "^1.32.5",
54 | "sass-loader": "^10.1.1",
55 | "style-loader": "^2.0.0",
56 | "webpack": "^5.3.2",
57 | "webpack-cli": "^4.1.0"
58 | }
59 | }
60 |
--------------------------------------------------------------------------------
/test/ui/accessibility.test.js:
--------------------------------------------------------------------------------
1 | import defaultSwitch, { initDefaultSwitch } from '../../src/ui/index';
2 | import { FEMALE } from '../../src/ivrita';
3 |
4 | // Jest can't read SCSS, and we don't need it anyway
5 | jest.mock('../../src/ui/style.scss', () => ({}));
6 |
7 | beforeAll(() => {
8 | if (!document.getElementsByClassName('ivrita-switch').length) {
9 | initDefaultSwitch();
10 | }
11 | expect(document.getElementsByClassName('ivrita-switch').length).toEqual(1);
12 | });
13 |
14 | test('All buttons in default switch contain aria-labels', () => {
15 | expect(Array.from(document.getElementsByClassName('ivrita-button')).map((el) => el.getAttribute('aria-label'))).toStrictEqual([
16 | 'שינוי לשון הפנייה של האתר לאיש',
17 | 'שינוי לשון הפנייה של האתר לאישה',
18 | 'שינוי לשון הפנייה של האתר לניטרלי',
19 | ]);
20 | });
21 |
22 | test('The selected button has an aria-selected attribute', () => {
23 | expect(Array.from(document.getElementsByClassName('ivrita-button')).filter((el) => el.getAttribute('aria-selected') === 'true').length).toEqual(1);
24 |
25 | defaultSwitch.setMode(FEMALE);
26 |
27 | expect(Array.from(document.getElementsByClassName('ivrita-button')).filter((el) => el.getAttribute('aria-selected') === 'true').length).toEqual(1);
28 | expect(document.querySelector('.ivrita-mode-changer[data-ivrita-mode="2"]').getAttribute('aria-selected')).toEqual('true');
29 | });
30 |
31 | test('The list has the right roles and aria-activedescendant', () => {
32 | defaultSwitch.setMode(FEMALE);
33 |
34 | const defaultSwitchElement = document.getElementById('ivrita-default-switch');
35 |
36 | expect(defaultSwitchElement.getAttribute('role')).toEqual('listbox');
37 | expect(defaultSwitchElement.getAttribute('aria-activedescendant')).toEqual(`ivrita-default-switch-button-${FEMALE}`);
38 |
39 | expect(
40 | Array.from(defaultSwitchElement.getElementsByClassName('ivrita-mode-changer'))
41 | .every((e) => e.getAttribute('role') === 'option'),
42 | ).toEqual(true);
43 | });
44 |
--------------------------------------------------------------------------------
/src/ivrita.js:
--------------------------------------------------------------------------------
1 | import rules from './rules';
2 |
3 | const PROTECTED = '__IVRITA_PROTECTED__';
4 | const protectedRegexp = new RegExp(`\\{${PROTECTED}:(\\d+):${PROTECTED}\\}`, 'g');
5 |
6 | export const ORIGINAL = 0;
7 |
8 | export const MALE = 1;
9 |
10 | export const FEMALE = 2;
11 |
12 | export const NEUTRAL = 3;
13 |
14 | export const GENDERS = [ORIGINAL, MALE, FEMALE, NEUTRAL];
15 |
16 | export const genderize = (originalText, gender, doneFunc) => {
17 | let genderized = originalText;
18 | const bracedStrings = [];
19 |
20 | if (genderized.includes('{')) {
21 | // Remove braced parts from text and save them aside
22 | genderized = genderized.replace(/\{(.*?)\}/g, (matched, string, index) => {
23 | bracedStrings[index] = string;
24 | return `{${PROTECTED}:${index}:${PROTECTED}}`;
25 | });
26 | }
27 |
28 | let prev = originalText;
29 | const used = [];
30 | rules.forEach(([pattern, male, female, neutral]) => {
31 | let replacement;
32 | switch (gender) {
33 | case FEMALE:
34 | replacement = female;
35 | break;
36 |
37 | case MALE:
38 | replacement = male;
39 | break;
40 |
41 | case NEUTRAL:
42 | default:
43 | if (typeof neutral !== 'undefined') replacement = neutral;
44 | break;
45 | }
46 | if (replacement !== undefined) {
47 | genderized = genderized.replace(pattern, replacement);
48 | }
49 |
50 | if (typeof doneFunc === 'function' && prev !== genderized) {
51 | used.push(pattern);
52 | prev = genderized;
53 | }
54 | });
55 |
56 | if (bracedStrings.length) {
57 | // Bring back braced parts
58 | genderized = genderized.replace(protectedRegexp, (matched, group) => {
59 | const parsedIndex = parseInt(group, 10);
60 | if (bracedStrings[parsedIndex]) {
61 | return bracedStrings[parsedIndex];
62 | }
63 | return '';
64 | });
65 | }
66 |
67 | if (typeof doneFunc === 'function') {
68 | doneFunc(used);
69 | }
70 | return genderized;
71 | };
72 |
--------------------------------------------------------------------------------
/webpack.config.js:
--------------------------------------------------------------------------------
1 | // babel loader, testing for files that have a .js(x) extension
2 | // (except for files in our node_modules folder!).
3 | const babelLoader = {
4 | test: /\.jsx?$/,
5 | exclude: /node_modules/,
6 | loader: 'babel-loader',
7 | options: {
8 | compact: true, // because I want readable output
9 | },
10 | };
11 |
12 | module.exports = [{
13 | // entry is the "main" source file we want to include/import
14 | entry: './src/element.js',
15 | devtool: 'source-map',
16 | // output tells webpack where to put the bundle it creates
17 | output: {
18 | // in the case of a "plain global browser library", this
19 | // will be used as the reference to our module that is
20 | // hung off of the window object.
21 | library: 'Ivrita',
22 | // We want webpack to build a UMD wrapper for our module
23 | libraryTarget: 'umd',
24 | // the destination file name
25 | filename: 'ivrita.min.js',
26 | libraryExport: 'default',
27 | },
28 | module: {
29 | rules: [
30 | babelLoader,
31 | ],
32 | },
33 | }, {
34 | entry: './src/ui/index.js',
35 | devtool: 'source-map',
36 | output: {
37 | library: ['Ivrita', 'ui'],
38 | libraryTarget: 'umd',
39 | filename: 'ivrita.ui.min.js',
40 | libraryExport: 'default',
41 | },
42 | externals: {
43 | '../element': 'Ivrita',
44 | },
45 | module: {
46 | rules: [
47 | babelLoader,
48 | {
49 | test: /\.s[ac]ss$/i,
50 | use: [
51 | // Creates `style` nodes from JS strings
52 | 'style-loader',
53 | // Translates CSS into CommonJS
54 | 'css-loader',
55 | // Compiles Sass to CSS
56 | 'sass-loader',
57 | ],
58 | },
59 | { // Keep font files the same, in the dist/fonts directory
60 | test: /\.(woff(2)?|ttf|eot|svg)(\?v=\d+\.\d+\.\d+)?$/,
61 | use: [
62 | {
63 | loader: 'file-loader',
64 | options: {
65 | name: '[name].[ext]',
66 | outputPath: 'fonts/',
67 | },
68 | },
69 | ],
70 | },
71 | ],
72 | },
73 | }];
74 |
--------------------------------------------------------------------------------
/test/attributes.test.js:
--------------------------------------------------------------------------------
1 | import Ivrita from '../src/element';
2 |
3 | import { FEMALE } from '../src/ivrita';
4 |
5 | const template = `
6 |
17 | `;
18 |
19 | test('Input placeholder', () => {
20 | document.body.innerHTML = template;
21 | const name = document.getElementById('name');
22 | const city = document.getElementById('city');
23 |
24 | const ivrita = new Ivrita(document.body);
25 | ivrita.setMode(FEMALE);
26 |
27 | expect(name.getAttribute('placeholder')).toBe('הכניסי את שמך כאן');
28 | expect(city.getAttribute('placeholder')).toBe('הכניסי את העיר שבה את גרה כאן');
29 | });
30 |
31 | test('Link title', () => {
32 | document.body.innerHTML = template;
33 | const link = document.querySelector('a');
34 |
35 | const ivrita = new Ivrita(document.body);
36 | ivrita.setMode(FEMALE);
37 |
38 | expect(link.innerHTML).toBe('התנתקי');
39 | expect(link.getAttribute('title')).toBe('לחצי כאן כדי להתנתק');
40 | });
41 |
42 | test('Buttons', () => {
43 | document.body.innerHTML = template;
44 | const button = document.querySelector('button');
45 | const inputSubmit = document.querySelector('input[type=submit]');
46 | const inputButton = document.querySelector('input[type=button]');
47 |
48 | const ivrita = new Ivrita(document.body);
49 | ivrita.setMode(FEMALE);
50 |
51 | expect(button.innerHTML).toBe('נקי את הטופס');
52 | expect(inputSubmit.value).toBe('שלחי');
53 | expect(inputButton.value).toBe('בטלי');
54 | });
55 |
56 | test('Custom attribute', () => {
57 | document.body.innerHTML = template;
58 | const button = document.querySelector('button');
59 |
60 | const ivrita = new Ivrita(document.body);
61 | ivrita.relavantAttributes['button[data-custom-text]'] = ['data-custom-text'];
62 | ivrita.registerTextAttributes(document.body);
63 | ivrita.setMode(FEMALE);
64 |
65 | expect(button.getAttribute('data-custom-text')).toBe('לא יודעת איך?');
66 | });
67 |
--------------------------------------------------------------------------------
/src/ui/custom.js:
--------------------------------------------------------------------------------
1 | // eslint-disable-next-line no-unused-vars
2 | import dom from 'jsx-render';
3 | import IvritaElement from '../element';
4 | import { MALE, FEMALE, NEUTRAL } from '../ivrita';
5 | import IvritaSwitch from './switch';
6 |
7 | export default class CustomSwitch extends IvritaSwitch {
8 | buttons = new Map();
9 |
10 | constructor(element, buttonsSelector, ...ivritaInstances) {
11 | if (ivritaInstances.length === 0 && typeof window._ivrita !== 'undefined') {
12 | super(window._ivrita);
13 | } else {
14 | super(...ivritaInstances);
15 | }
16 |
17 | this.element = element;
18 | this.buttonsSelector = buttonsSelector;
19 |
20 | this.listenForClicks();
21 | this.listenForExternalChanges();
22 | }
23 |
24 | listenForClicks() {
25 | Array.from(this.element.querySelectorAll(this.buttonsSelector)).forEach((button) => {
26 | const btnModeStr = button.dataset.ivritaMode;
27 | let btnMode;
28 | switch (btnModeStr.toUpperCase()) {
29 | case 'MALE':
30 | btnMode = MALE;
31 | break;
32 |
33 | case 'FEMALE':
34 | btnMode = FEMALE;
35 | break;
36 |
37 | case 'NEUTRAL':
38 | btnMode = NEUTRAL;
39 | break;
40 |
41 | default:
42 | btnMode = null;
43 | }
44 |
45 | if (btnMode !== null) {
46 | button.addEventListener('click', (e) => {
47 | e.preventDefault();
48 |
49 | this.setMode(btnMode);
50 | this.setActiveButton(btnMode);
51 | });
52 |
53 | this.buttons.set(button, btnMode);
54 | }
55 | });
56 | }
57 |
58 | listenForExternalChanges() {
59 | this.ivritaInstances.forEach((ivritaInstance) => {
60 | if (ivritaInstance.elements.length) {
61 | ivritaInstance.elements[0].addEventListener(IvritaElement.EVENT_MODE_CHANGED,
62 | ({ detail: { mode, firingInstance } }) => {
63 | if (firingInstance === ivritaInstance) { // Skip events bubbled by other instances
64 | this.setActiveButton(mode);
65 | }
66 | });
67 | }
68 | });
69 | }
70 |
71 | setActiveButton(newMode) {
72 | this.buttons.forEach((value, btn) => {
73 | if (newMode === value) {
74 | btn.classList.add('ivrita-active');
75 | } else {
76 | btn.classList.remove('ivrita-active');
77 | }
78 | });
79 | }
80 | }
81 |
--------------------------------------------------------------------------------
/test/rules/parenthesis.test.js:
--------------------------------------------------------------------------------
1 | import {
2 | genderize, FEMALE, MALE, NEUTRAL,
3 | } from '../../src/ivrita';
4 |
5 | test('Singular possessive', () => {
6 | expect(genderize('חבר(ת)ו', FEMALE)).toBe('חברתו');
7 | expect(genderize('חבר(ת)ו', MALE)).toBe('חברו');
8 | });
9 |
10 | test('Grandma/pa', () => {
11 | expect(genderize('סב(ת)א', FEMALE)).toBe('סבתא');
12 | expect(genderize('סב(ת)א', MALE)).toBe('סבא');
13 | });
14 |
15 | test('Men/Women', () => {
16 | expect(genderize('(א)נשים', FEMALE)).toBe('נשים');
17 | expect(genderize('(א)נשים', MALE)).toBe('אנשים');
18 | });
19 |
20 | test('Third person ending Tav', () => {
21 | expect(genderize('חושב(ת)', FEMALE)).toBe('חושבת');
22 | expect(genderize('חושב(ת)', MALE)).toBe('חושב');
23 | });
24 |
25 | test('Plural possessive', () => {
26 | expect(genderize('מתנגד(ות)יו', FEMALE)).toBe('מתנגדותיו');
27 | expect(genderize('מתנגד(ות)יו', MALE)).toBe('מתנגדיו');
28 |
29 | expect(genderize('מתנגד(ות)יהן', FEMALE)).toBe('מתנגדותיהן');
30 | expect(genderize('מתנגד(ות)יהן', MALE)).toBe('מתנגדיהן');
31 |
32 | expect(genderize('מעריצ(ות)יו', FEMALE)).toBe('מעריצותיו');
33 | expect(genderize('מעריצ(ות)יו', MALE)).toBe('מעריציו');
34 | });
35 |
36 | test('Yod in the middle', () => {
37 | expect(genderize('עלי(י)ך', FEMALE)).toBe('עלייך');
38 | expect(genderize('עלי(י)ך', MALE)).toBe('עליך');
39 |
40 | expect(genderize('פנ(י)יך', FEMALE)).toBe('פנייך');
41 | expect(genderize('פנ(י)יך', MALE)).toBe('פניך');
42 |
43 | expect(genderize('הפע(י)ל/י', FEMALE)).toBe('הפעילי');
44 | expect(genderize('הפע(י)ל/י', MALE)).toBe('הפעל');
45 | });
46 |
47 | test('Neutral plural', () => {
48 | expect(genderize('הודעתך(ם)', FEMALE)).toBe('הודעתך');
49 | expect(genderize('הודעתך(ם)', MALE)).toBe('הודעתך');
50 | expect(genderize('הודעתך(ם)', NEUTRAL)).toBe('הודעתכם');
51 | expect(genderize('הודעתך(ן)', NEUTRAL)).toBe('הודעתכן');
52 | expect(genderize('הודעתך(םן)', NEUTRAL)).toBe('הודעתכםן');
53 | expect(genderize('הודעתך(ןם)', NEUTRAL)).toBe('הודעתכןם');
54 | expect(genderize('הודעתך(ם.ן)', NEUTRAL)).toBe('הודעתכם.ן');
55 | expect(genderize('הודעתך(ם/ן)', NEUTRAL)).toBe('הודעתכם/ן');
56 |
57 | expect(genderize('שלך(ם)', FEMALE)).toBe('שלך');
58 | expect(genderize('שלך(ם)', MALE)).toBe('שלך');
59 | expect(genderize('שלך(ם)', NEUTRAL)).toBe('שלכם');
60 | expect(genderize('שלך(ן)', NEUTRAL)).toBe('שלכן');
61 |
62 | expect(genderize('שלכ(ם)', FEMALE)).toBe('שלך');
63 | expect(genderize('שלכ(ם)', MALE)).toBe('שלך');
64 | expect(genderize('שלכ(ם)', NEUTRAL)).toBe('שלכם');
65 | expect(genderize('שלכ(ן)', NEUTRAL)).toBe('שלכן');
66 | });
67 |
--------------------------------------------------------------------------------
/test/rules/predefined.test.js:
--------------------------------------------------------------------------------
1 | import { genderize, FEMALE, MALE } from '../../src/ivrita';
2 |
3 | test('Whole words', () => {
4 | expect(genderize('אנשי/ות עסקים', FEMALE)).toBe('נשות עסקים');
5 | expect(genderize('אנשי/ות עסקים', MALE)).toBe('אנשי עסקים');
6 |
7 | expect(genderize('א.נשים', FEMALE)).toBe('נשים');
8 | expect(genderize('א.נשים', MALE)).toBe('אנשים');
9 |
10 | expect(genderize('א.נשי', FEMALE)).toBe('נשות');
11 | expect(genderize('א.נשי', MALE)).toBe('אנשי');
12 |
13 | expect(genderize('איש/ת', FEMALE)).toBe('אשת');
14 | expect(genderize('איש/ת', MALE)).toBe('איש');
15 | expect(genderize('איש/אשת', FEMALE)).toBe('אשת');
16 | expect(genderize('איש/אשת', MALE)).toBe('איש');
17 | expect(genderize('אשת/איש', FEMALE)).toBe('אשת');
18 | expect(genderize('אשת/איש', MALE)).toBe('איש');
19 | expect(genderize('גבר/אישה', FEMALE)).toBe('אישה');
20 | expect(genderize('גבר/אישה', MALE)).toBe('גבר');
21 | expect(genderize('איש/אישה', MALE)).toBe('איש');
22 |
23 | expect(genderize('אח/ות', FEMALE)).toBe('אחות');
24 | expect(genderize('אח/ות', MALE)).toBe('אח');
25 |
26 | expect(genderize('אחי/ותי', FEMALE)).toBe('אחותי');
27 | expect(genderize('אחי/ותי', MALE)).toBe('אחי');
28 |
29 | expect(genderize('לו/לה, לה/לו', FEMALE)).toBe('לה, לה');
30 | expect(genderize('לו/לה, לה/לו', MALE)).toBe('לו, לו');
31 |
32 | expect(genderize('בן/בת, בת/בן', FEMALE)).toBe('בת, בת');
33 | expect(genderize('בן/בת, בת/בן', MALE)).toBe('בן, בן');
34 |
35 | expect(genderize('הוא/היא, היא/הוא', FEMALE)).toBe('היא, היא');
36 | expect(genderize('הוא/היא, היא/הוא', MALE)).toBe('הוא, הוא');
37 |
38 | expect(genderize('אנשי/ות', FEMALE)).toBe('נשות');
39 | expect(genderize('אנשי/ות', MALE)).toBe('אנשי');
40 | expect(genderize('א.נשות', FEMALE)).toBe('נשות');
41 | expect(genderize('א.נשות', MALE)).toBe('אנשי');
42 |
43 | expect(genderize('מישהו/י', FEMALE)).toBe('מישהי');
44 | expect(genderize('מישהו/י', MALE)).toBe('מישהו');
45 |
46 | expect(genderize('אחד/ת, אחד/אחת, אחת/אחד', FEMALE)).toBe('אחת, אחת, אחת');
47 | expect(genderize('אחד/ת, אחד/אחת, אחת/אחד', MALE)).toBe('אחד, אחד, אחד');
48 |
49 | expect(genderize('יקירי/תי', FEMALE)).toBe('יקירתי');
50 | expect(genderize('יקירי/תי', MALE)).toBe('יקירי');
51 |
52 | expect(genderize('זה/זאת', FEMALE)).toBe('זאת');
53 | expect(genderize('זה/זאת', MALE)).toBe('זה');
54 | expect(genderize('זה/ו', FEMALE)).toBe('זו');
55 | expect(genderize('זה/ו', MALE)).toBe('זה');
56 | expect(genderize('זו/ה', FEMALE)).toBe('זו');
57 | expect(genderize('זו/ה', MALE)).toBe('זה');
58 |
59 | expect(genderize('נשוי/אה', FEMALE)).toBe('נשואה');
60 | expect(genderize('נשוי/אה', MALE)).toBe('נשוי');
61 | expect(genderize('נשוי/ה', FEMALE)).toBe('נשואה');
62 | expect(genderize('נשוי/ה', MALE)).toBe('נשוי');
63 | });
64 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | 
2 | 
3 |
4 |
5 |
6 |
7 | 
8 |
9 |
10 |
Ivrita JavaScript Library
11 |
12 |
13 | Ivrita is an open-source set of typographic tools for gender equality in Hebrew.
14 |
15 | Read about the project in Hebrew »
16 |
17 |
18 | Chrome Extension
19 | ·
20 | WordPress Plugin
21 |
22 |
23 |
24 | ## Install on your website
25 | > If your website uses WordPress, check out the [WordPress Plugin](https://he.wordpress.org/plugins/ivrita) for easy usage
26 |
27 | Installing the library on your website requires 3 steps:
28 | 1. Include the minified JS file:
29 | ```html
30 |
31 | ```
32 | 2. Initialize the Ivrita object:
33 | * First argument is the DOM element(s) for which texts should be changed (default: `` and ``)
34 | * Second argument is the initial gender to be set (default: `Ivrita.NEUTRAL`)
35 | ```JavaScript
36 | var ivrita = new Ivrita(document.querySelector('#content'), Ivrita.FEMALE);
37 | ```
38 |
39 | 3. Change the gender later with `setMode` on the object instance:
40 | ```JavaScript
41 | ivrita.setMode(Ivrita.MALE); // Possible options: Ivrita.MALE, Ivrita.FEMALE, Ivrita.NEUTRAL, Ivrita.ORIGINAL
42 | ```
43 | That's it!
44 |
45 | ## Install Source
46 |
47 | Use `npm` to install the package files locally, to include in another JS library:
48 |
49 | ```bash
50 | npm install ivrita
51 | ```
52 |
53 | ```JavaScript
54 | import Ivrita from 'ivrita';
55 |
56 | console.log(Ivrita.genderize('ברוכים/ות הבאות/ים', Ivrita.FEMALE));
57 | ```
58 |
59 | ## Contributing
60 | Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
61 |
62 | Most typical changes to the Hebrew genderization should be added to the `rules.js` file. Note that the order of rules matters, since the rules are executed one by one and can conflict.
63 |
64 | Use `npm test` (or `npm run test-watch`) to make sure your changes didn't break any functionality, and please make sure to update tests for new features or bug fixes.
65 |
--------------------------------------------------------------------------------
/test/rules/unchanged.test.js:
--------------------------------------------------------------------------------
1 | import { genderize, FEMALE, MALE } from '../../src/ivrita';
2 |
3 | test('Multiple options slash', () => {
4 | expect(genderize('ו/או', FEMALE)).toBe('ו/או');
5 | expect(genderize('ו/או', MALE)).toBe('ו/או');
6 |
7 | expect(genderize('או/או', FEMALE)).toBe('או/או');
8 | expect(genderize('או/או', MALE)).toBe('או/או');
9 | });
10 |
11 | test('Multiple words slash', () => {
12 | expect(genderize('אבן/בתיאבון', FEMALE)).toBe('אבן/בתיאבון');
13 | expect(genderize('אבן/בתיאבון', MALE)).toBe('אבן/בתיאבון');
14 |
15 | expect(genderize('יספרו/נהרו', FEMALE)).toBe('יספרו/נהרו'); // unchanged
16 | expect(genderize('יספרו/נהרו', MALE)).toBe('יספרו/נהרו'); // unchanged
17 |
18 | expect(genderize('הלו/להבה', FEMALE)).toBe('הלו/להבה'); // unchanged
19 | expect(genderize('הלו/להבה', MALE)).toBe('הלו/להבה'); // unchanged
20 |
21 | expect(genderize('בכה/תהום/שלום', FEMALE)).toBe('בכה/תהום/שלום'); // unchanged
22 | expect(genderize('בכה/תהום/שלום', MALE)).toBe('בכה/תהום/שלום'); // unchanged
23 |
24 | expect(genderize('יזם/יתד', FEMALE)).toBe('יזם/יתד'); // unchanged
25 | expect(genderize('יזם/יתד', MALE)).toBe('יזם/יתד'); // unchanged
26 |
27 | expect(genderize('יזמים/יותר', FEMALE)).toBe('יזמים/יותר'); // unchanged
28 | expect(genderize('יזמים/יותר', MALE)).toBe('יזמים/יותר'); // unchanged
29 |
30 | expect(genderize('ים/הר', FEMALE)).toBe('ים/הר'); // unchanged
31 | expect(genderize('ים/הר', MALE)).toBe('ים/הר'); // unchanged
32 | });
33 |
34 | test('Singular/Plural slash', () => {
35 | expect(genderize('תפקיד/ים', FEMALE)).toBe('תפקיד/ים'); // unchanged
36 | expect(genderize('תפקיד/ים', MALE)).toBe('תפקיד/ים'); // unchanged
37 | });
38 |
39 | test('Final letters and abbreviations', () => {
40 | expect(genderize('דרושים׳', FEMALE)).toBe('דרושים׳'); // unchanged
41 | expect(genderize('דרושים׳', MALE)).toBe('דרושים׳'); // unchanged
42 |
43 | expect(genderize('מע”מ', FEMALE)).toBe('מע”מ'); // unchanged
44 | expect(genderize('מע”מ', MALE)).toBe('מע”מ'); // unchanged
45 |
46 | expect(genderize('פ', FEMALE)).toBe('פ'); // unchanged
47 | expect(genderize('פ', MALE)).toBe('פ'); // unchanged
48 |
49 | expect(genderize('דסקטופ', FEMALE)).toBe('דסקטופ'); // unchanged
50 | expect(genderize('דסקטופ', MALE)).toBe('דסקטופ'); // unchanged
51 | });
52 |
53 | test('Words which look like genders', () => {
54 | expect(genderize('תותים', FEMALE)).toBe('תותים'); // unchanged
55 | expect(genderize('תותים', MALE)).toBe('תותים'); // unchanged
56 |
57 | expect(genderize('צוותים', FEMALE)).toBe('צוותים'); // unchanged
58 | expect(genderize('צוותים', MALE)).toBe('צוותים'); // unchanged
59 | });
60 |
61 | test('Words that look like beginnings', () => {
62 | expect(genderize('מישהי/תבוא', FEMALE)).toBe('מישהי/תבוא'); // unchanged
63 | expect(genderize('מישהי/תבוא', MALE)).toBe('מישהי/תבוא'); // unchanged
64 | });
65 |
--------------------------------------------------------------------------------
/src/ui/default.js:
--------------------------------------------------------------------------------
1 | // eslint-disable-next-line no-unused-vars
2 | import dom from 'jsx-render';
3 | import {
4 | iconTitle,
5 | aboutLinkText,
6 | defaultMaleLabel,
7 | defaultFemaleLabel,
8 | defaultNeutralLabel,
9 | ariaLabel,
10 | } from './hebrew';
11 |
12 | import './style.scss';
13 |
14 | import Ivrita from '../element';
15 | import IvritaSwitch from './switch';
16 |
17 | export default class DefaultSwitch extends IvritaSwitch {
18 | /**
19 | * The switch configuration.
20 | *
21 | * The defaults are listed bellow, properties can be overridden by using
22 | * the `ivrita-ui-ready` event:
23 | *
24 | * ```
25 | * document.addEventListener('ivrita-ui-ready', function() {
26 | * Ivrita.ui.default.config.modes[Ivrita.MALE].label = 'גבר';
27 | * });
28 | * ```
29 | */
30 | config = {
31 | position: 'left',
32 | iconTitle,
33 | aboutLinkText,
34 | ariaLabel,
35 | aboutLinkURL: 'https://alefalefalef.co.il/ivrita/',
36 | style: 0,
37 | logoIcon: '⚥︎',
38 | modes: {
39 | [Ivrita.MALE]: {
40 | label: defaultMaleLabel,
41 | icon: '♂︎',
42 | order: 1,
43 | },
44 | [Ivrita.FEMALE]: {
45 | label: defaultFemaleLabel,
46 | icon: '♀︎',
47 | order: 2,
48 | },
49 | [Ivrita.NEUTRAL]: {
50 | label: defaultNeutralLabel,
51 | icon: '⚥︎',
52 | order: 3,
53 | },
54 | },
55 | default: Ivrita.NEUTRAL,
56 | }
57 |
58 | /**
59 | * @type {HTMLElement}
60 | */
61 | element;
62 |
63 | setMode(mode) {
64 | this.element.querySelectorAll('a.ivrita-mode-changer').forEach((e) => {
65 | if (parseInt(e.dataset.ivritaMode, 10) === mode) {
66 | e.classList.add('ivrita-active');
67 | e.setAttribute('aria-selected', 'true');
68 | document.getElementById('ivrita-default-switch').setAttribute('aria-activedescendant', e.getAttribute('id'));
69 | } else {
70 | e.classList.remove('ivrita-active');
71 | e.setAttribute('aria-selected', 'false');
72 | }
73 | });
74 | this.element.querySelector(`a[data-ivrita-mode="${mode}"]`).classList.add('ivrita-active');
75 |
76 | super.setMode(mode);
77 | }
78 |
79 | render() {
80 | return (
81 | <div id="ivrita-default-switch" class={`ivrita-switch ivrita-switch--${this.config.position}`} tabindex="0" title={ this.config.iconTitle } role="listbox">
82 | <a href="#" class="ivrita-logo" tabindex="-1" title={ this.config.iconTitle } dangerouslySetInnerHTML={{ __html: this.config.logoIcon }}></a>
83 | {
84 | Object.keys(this.config.modes)
85 | .sort((mode1, mode2) => this.config.modes[mode1].order - this.config.modes[mode2].order)
86 | .map((mode) => parseInt(mode, 10))
87 | .map((mode) => (
88 | <a href="#"
89 | id={`ivrita-default-switch-button-${mode}`}
90 | class={`ivrita-mode-changer ivrita-button ivrita-button-style-${this.config.style}`}
91 | data-ivrita-mode={ mode }
92 | title={ this.config.modes[mode].label }
93 | aria-label={ this.config.ariaLabel && this.config.ariaLabel.includes('%s')
94 | ? this.config.ariaLabel.replace('%s', this.config.modes[mode].label)
95 | : this.config.modes[mode].label }
96 | role="option"
97 | ref={ super.ref }
98 | onClick={ (e) => { e.preventDefault(); this.setMode(mode); } }
99 | dangerouslySetInnerHTML={{ __html: this.config.modes[mode].icon }}
100 | ></a>
101 | ))
102 | }
103 | <a href={ this.config.aboutLinkURL } class="ivrita-info-link" title={ this.config.aboutLinkText } target="_blank">ⓘ</a>
104 | </div>
105 | );
106 | }
107 |
108 | build() {
109 | this.element = this.render();
110 | }
111 |
112 | init() {
113 | // Dispatch the event, in order to allow external reconfiguration
114 | document.dispatchEvent(new CustomEvent(this.constructor.EVENT_INIT, { bubbles: true }));
115 |
116 | this.build();
117 | document.body.appendChild(this.element);
118 |
119 | let storedMode = window.localStorage.getItem('ivrita-mode');
120 | if (!Number.isNaN(parseInt(storedMode, 10))) {
121 | storedMode = parseInt(storedMode, 10);
122 | }
123 | if (!Ivrita.GENDERS.includes(storedMode)) {
124 | if (Ivrita.GENDERS.includes(Ivrita[storedMode])) {
125 | storedMode = Ivrita[storedMode];
126 | } else {
127 | storedMode = Ivrita.defaultMode;
128 | }
129 | }
130 | if (storedMode) {
131 | this.setMode(storedMode);
132 | } else if (this.config.default) {
133 | this.setMode(this.config.default);
134 | }
135 | }
136 |
137 | rebuild() {
138 | this.element.remove();
139 | this.init();
140 | }
141 | }
142 |
--------------------------------------------------------------------------------
/src/rules.js:
--------------------------------------------------------------------------------
1 | import {
2 | SEP, G, W, FIN, B, HEB, NCB, CB,
3 | } from './utils/characters';
4 |
5 | import {
6 | finals,
7 | finnables, toFin, toNotFin,
8 | } from './utils/finals';
9 | import {
10 | custom, verbsFemaleExtraYod, verbsFemaleKeepVav, pluralsWithExtraYod,
11 | } from './wordlists';
12 |
13 | // Marks are used by early rules to specify a position in a text
14 | // which should be addressed later by later rules.
15 | // For example, M_WORDFIN marks an artificial end of a word,
16 | // which was created by a rule (i.e. wasn't the end of the word in the original text)
17 | // and this ending should be checked for final letters errors (מ=>ם).
18 | const M_WORDFIN = '\u05c8'; // Not a real character
19 | const M_NOT_WORDFIN = '\u05c9'; // Not a real character
20 |
21 | const regexize = (p) => {
22 | p[0] = new RegExp(p[0], 'g');
23 |
24 | if (p[3] === true) {
25 | p[3] = `${p[1]}/${p[2]}`;
26 | }
27 | return p;
28 | };
29 |
30 | // Unisex rules match always replace the same string, mode-ignorantly.
31 | const unisex = (pattern, replacement) => [pattern, replacement, replacement, replacement];
32 |
33 | const matchAndNormalizeVerb = (word, addYod) => {
34 | const wordWithoutLastLetter = word.slice(0, word.length - 1);
35 | const lastLetter = word.slice(word.length - 1);
36 | let lastLetterMatcher = `(${lastLetter})`;
37 | if (finnables.includes(lastLetter)) {
38 | lastLetterMatcher = `(${toFin(lastLetter)}|${toNotFin(lastLetter)})`;
39 | }
40 |
41 | const femaleBase = `${wordWithoutLastLetter}${addYod ? 'י' : ''}${toNotFin(lastLetter)}`;
42 | const male = `${wordWithoutLastLetter}${toFin(lastLetter)}`;
43 | return [
44 | [`${wordWithoutLastLetter}${lastLetterMatcher}${SEP}י${SEP}ו${B}`, male, `${femaleBase}י`, `${femaleBase}ו`],
45 | [`${wordWithoutLastLetter}${lastLetterMatcher}${SEP}י${B}`, male, `${femaleBase}י`],
46 | ];
47 | };
48 |
49 | export default [
50 | // Whole Words
51 | ...custom,
52 |
53 | // הקשב/י => הקשב, הקשיבי
54 | ...verbsFemaleExtraYod.reduce((r, word) => r.concat(matchAndNormalizeVerb(word, true)), []),
55 |
56 | // קום/י => קום, קומי
57 | ...verbsFemaleKeepVav.reduce((r, word) => r.concat(matchAndNormalizeVerb(word, false)), []),
58 |
59 | // סטודנטים/ות => סטודנטים, סטודנטיות
60 | ...pluralsWithExtraYod.map((word) => {
61 | let targetWord = word;
62 | if (word.includes('(')) { // regex groups
63 | targetWord = word.replace(new RegExp('\\(.*?\\)'), '$2'); // TODO: support multiple groups
64 | }
65 | return [`${CB}${word}ים${SEP}י?ות${B}`, `$1${targetWord}ים`, `$1${targetWord}יות`];
66 | }),
67 |
68 | // Beginnings
69 | [`(${NCB}${W}{0,3})י${SEP}ת(${W}{2,})`, '$1י$2', '$1ת$2'], // שי/תכתוב
70 | [`(${NCB}${W}{0,3})ת${SEP}י(${W}{2,})`, '$1י$2', '$1ת$2'], // שת/יכתוב
71 |
72 | // Endings
73 |
74 | [`ו${SEP}ה${B}`, 'ו', 'ה'], // בגללה/ו
75 | [`ה${SEP}ו${B}`, 'ו', 'ה'], // בגללו/ה
76 | [`(${W})${SEP}ה${B}`, `$1${M_WORDFIN}`, `$1${M_NOT_WORDFIN}ה`], // חרוץ/ה
77 | ...finals.map(
78 | (f) => [`(${W})${f}${SEP}${toNotFin(f)}ה${B}`, `$1${f}${M_WORDFIN}`, `$1${toNotFin(f)}${M_NOT_WORDFIN}ה`],
79 | ), // מוכן/נה, חרוץ/צה
80 |
81 | [`(${W})ה?${SEP}תה${B}`, '$1ה', '$1תה'], // בכה/תה, רצ/תה
82 | [`(${W})יו${SEP}י?ה${B}`, '$1יו', '$1יה'], // מחקריו/יה
83 | [`(${W})ה${SEP}ית${B}`, '$1ה', '$1ית'], // מומחה/ית
84 | [`(${W})(ו?)י${SEP}ות${B}`, '$1$2י', '$1ות'], // מומחי/ות, שווי/ות
85 | [`(${W})ות${SEP}י${B}`, '$1י', '$1ות'], // מומחות/י
86 | [`(${W})${SEP}ית${B}`, `$1${M_WORDFIN}`, `$1${M_NOT_WORDFIN}ית`], // סטודנט/ית
87 |
88 | [`(${W})י${SEP}תי${B}`, '$1י', '$1תי'], // יקירי/תי
89 |
90 | [`(${W}{4,})אים${SEP}י?ות${B}`, '$1אים', '$1איות'], // ארגנטינאים/ות
91 |
92 | [`(${W})ווים${SEP}?ות${B}`, '$1ווים', '$1וות'], // שווים/ות
93 | [`(${W})וות${SEP}ים${B}`, '$1ווים', '$1וות'], // שוות/ים
94 | [`(${W})(י)?ים${SEP}?(י)?ות${B}`, '$1$2ים', '$1$2$3ות'], // מורים/ות
95 | [`(${W})(י)?ות${SEP}י?ים${B}`, '$1$2ים', '$1$2ות'], // מורות/ים
96 | [`(${W})י${SEP}ות${B}`, '$1י', '$1ות'], // עורכי/ות
97 |
98 | [`(${W})ה${SEP}י${SEP}ו${B}`, '$1ה', '$1י', '$1ו'], // ראה/י/ו
99 | [`(${W})ה${SEP}י${B}`, '$1ה', '$1י'], // ראה/י
100 | [`(${W})י${SEP}ה${SEP}ו${B}`, '$1ה', '$1י', '$1ו'], // ראי/ה/ו
101 | [`(${W})י${SEP}ה${B}`, '$1ה', '$1י'], // ראי/ה
102 | [`(${W}+)\\(י\\)(${W})${SEP}י${SEP}ו${B}`, '$1$2', '$1י$2י', '$1י$2ו'], // הפע(י)ל/י/ו
103 | [`(${W}+)\\(י\\)(${W})${SEP}י${B}`, '$1$2', '$1י$2י'], // הפע(י)ל/י
104 | [`(${HEB})ו(ו?)(${W})${SEP}י${SEP}ו${B}`, `$1$2ו$3${M_WORDFIN}`, `$1$2$2$3${M_NOT_WORDFIN}י`, `$1$2$3${M_NOT_WORDFIN}ו`], // כתוב/י/ו, דווח/י/ו
105 | [`(${HEB})ו(ו?)(${W})${SEP}י${B}`, `$1$2ו$3${M_WORDFIN}`, `$1$2$2$3${M_NOT_WORDFIN}י`], // כתוב/י, דווח/י
106 | [`(${W})${SEP}י${SEP}ו${B}`, `$1${M_WORDFIN}`, `$1${M_NOT_WORDFIN}י`, `$1${M_NOT_WORDFIN}ו`], // לך/י/ו
107 | [`(${W})${SEP}י${B}`, `$1${M_WORDFIN}`, `$1${M_NOT_WORDFIN}י`], // לך/י
108 |
109 | [`(${W})(ה)?${SEP}ת${B}`, `$1$2${M_WORDFIN}`, `$1${M_NOT_WORDFIN}ת`], // נהג/ת, רואה/ת חשבון
110 |
111 | [`(${W})ם${SEP}?ן${B}`, '$1ם', '$1ן'], // אתם/ן
112 | [`(${W})ן${SEP}?ם${B}`, '$1ם', '$1ן'], // אתן/ם
113 | [`ה(${W}+)י(${W})ו${SEP}נה${B}`, 'ה$1י$2ו', 'ה$1$2נה'], // הלבישו/נה
114 | [`(${W}+)ו${SEP}ת(${W}+)נה${B}`, '$1ו', 'ת$2נה'], // יצאו/תצאנה
115 | [`ת(${W}+)ו${SEP}נה${B}`, 'ת$1ו', 'ת$1נה'], // תדרכו/נה
116 | [`(${W}+)ו${SEP}נה${B}`, '$1ו', '$1נה'], // רקדו/נה
117 |
118 | // Parentheses
119 | [`(${W}+)\\(([ותי]{1,3})\\)([יוהםן]{1,3})${B}`, '$1$3', '$1$2$3'], // מתנגד(ות)יו, מתנגד(ות)יהם
120 | [`(${W}+)י\\(י\\)(${W}*)(${FIN})${B}`, '$1י$2$3', '$1יי$2$3'], // פני(י)ך
121 | [`(${W}+)\\(י\\)י(${W}*)(${FIN})${B}`, '$1י$2$3', '$1יי$2$3'], // פנ(י)יך
122 | [`\\(א\\)נשים${B}`, 'אנשים', 'נשים'], // (א)נשים
123 | [`(${W}+)ב\\(ת\\)${B}`, '$1ב', '$1בת'], // חושב(ת)
124 | [`(${W}+)(ך|כ)\\(([םן.\\/]{1,3})\\)${B}`, '$1ך', '$1ך', '$1כ$3'], // שלך(ם), שלך(ן)
125 |
126 | // Special Syntax
127 | ['\\[([^|]*?)\\|([^|]*?)\\|([^|]*?)\\]', '$1', '$2', '$3'], // [בן|בת|ילד]
128 | ['\\[([^|]*?)\\|([^|]*?)\\]', '$1', '$2', true], // [בן|בת]
129 |
130 | // Final Letters fixes
131 | unisex(`ץ${M_NOT_WORDFIN}`, 'צ'), // חרוץה
132 | unisex(`ך${M_NOT_WORDFIN}`, 'כ'), // משךי
133 | unisex(`ן${M_NOT_WORDFIN}`, 'נ'), // השעןי
134 | unisex(`ם${M_NOT_WORDFIN}`, 'מ'), // יזםית
135 | unisex(`ף${M_NOT_WORDFIN}`, 'פ'), // פילוסוףית
136 |
137 | unisex(`([^${G}]+)צ${M_WORDFIN}`, '$1ץ'), // חרוצ
138 | unisex(`([^${G}]+)כ${M_WORDFIN}`, '$1ך'), // משוכ
139 | unisex(`([^${G}]+)נ${M_WORDFIN}`, '$1ן'), // השענ
140 | unisex(`([^${G}]+)מ${M_WORDFIN}`, '$1ם'), // יזמ
141 | unisex(`([^${G}]+)פ${M_WORDFIN}`, '$1ף'), // פילוסופ
142 |
143 | // Remove marks
144 | unisex(`[${M_WORDFIN}${M_NOT_WORDFIN}]`, ''),
145 | ].map(regexize);
146 |
--------------------------------------------------------------------------------
/src/ui/style.scss:
--------------------------------------------------------------------------------
1 | /**
2 | * Switch
3 | */
4 |
5 | @font-face {
6 | font-family: 'Ivritacons';
7 | font-weight: '400';
8 | src: url('fonts/ivritacons-alefalefalef.woff2') format("woff2"), url('fonts/ivritacons-alefalefalef.woff') format("woff");
9 | }
10 |
11 | $ivrita-accent: #6306ec;
12 |
13 | .ivrita-switch *, .ivrita-mode-changer * {
14 | margin: 0;
15 | padding: 0;
16 | outline: 0;
17 | font-size: 30px;
18 | font-weight: normal;
19 | font-style: normal;
20 | border: 0;
21 | text-decoration: none;
22 | list-style-type: none;
23 | min-width: auto;
24 | min-height: auto;
25 | max-width: none;
26 | max-height: none;
27 | -webkit-text-stroke: none;
28 | -moz-text-stroke: initial;
29 | -ms-text-stroke: initial;
30 | word-spacing: normal;
31 | text-align: left;
32 | width: auto;
33 | height: auto;
34 | position: static;
35 | display: inline-block;
36 | border: 0;
37 | float: none;
38 | background: none;
39 | border-radius: 0;
40 | box-shadow: none;
41 | direction: ltr;
42 | visibility: visible;
43 | opacity: 1;
44 | text-shadow: none;
45 | outline: 0;
46 | vertical-align: unset;
47 | white-space: normal;
48 | letter-spacing: 0;
49 | }
50 |
51 | .ivrita-switch {
52 | z-index: 999999;
53 | background-color: rgba(255, 255, 255, 0.8);
54 | position: fixed;
55 | top: calc(50% - 1em);
56 | left: -1px;
57 | border-radius: 0 7px 7px 0;
58 | transition: .2s all ease-out .1s;
59 | border: 1.1px solid #222;
60 | font-size: 30px;
61 | min-width: 40px;
62 | padding: 3px 0 0;
63 | overflow: hidden;
64 |
65 | *, &:before, &:after {
66 | box-sizing: border-box;
67 | -webkit-box-sizing: border-box;
68 | -moz-box-sizing: border-box;
69 | }
70 |
71 | &.ivrita-switch--right {
72 | left: auto;
73 | right: -1px;
74 | border-radius: 7px 0 0 7px;
75 | }
76 |
77 | a {
78 | font-family: 'Ivritacons' !important;
79 | font-weight: normal !important;
80 | font-style: normal !important;
81 | transition: .1s all ease-out;
82 | display: block;
83 | color: #2d2828;
84 | line-height: 1em;
85 | -webkit-font-smoothing: antialiased;
86 | -moz-osx-font-smoothing: grayscale;
87 | text-align: center;
88 | width: 33px;
89 | height: 33px;
90 | line-height: 33px;
91 | margin: 0 3px;
92 | overflow: hidden;
93 | text-decoration: none !important;
94 |
95 | &.ivrita-logo {
96 | transition: .1s all ease-out;
97 | }
98 |
99 | &.ivrita-button {
100 | visibility: hidden;
101 | border-radius: 5px;
102 | height: 0;
103 | transition: .2s all ease-out;
104 | overflow: hidden;
105 | }
106 |
107 | &.ivrita-button {
108 | &.ivrita-active:not(.ivrita-button-style-0) {
109 | background: #555;
110 | color: #fff;
111 | }
112 |
113 | &.ivrita-button-style-0.ivrita-active {
114 | -webkit-font-feature-settings: "swsh";
115 | font-feature-settings: "swsh";
116 | }
117 |
118 | @for $i from 1 through 7 {
119 | &.ivrita-button-style-#{$i} {
120 | -webkit-font-feature-settings: "ss0#{$i}";
121 | font-feature-settings: "ss0#{$i}";
122 | }
123 | }
124 |
125 | &:hover, &:focus {
126 | background-color: rgba(0, 0, 0, 0.1);
127 | color: $ivrita-accent;
128 | }
129 |
130 | &.ivrita-active:focus {
131 | border: 1px solid $ivrita-accent;
132 | }
133 | }
134 |
135 | &.ivrita-info-link {
136 | transition: .2s all ease-out;
137 | visibility: hidden;
138 | font-size: 20px;
139 | line-height: 21px;
140 | height: 0;
141 | width: 100%;
142 |
143 | &:hover, &:focus {
144 | color: $ivrita-accent;
145 | -webkit-font-feature-settings: "ss01";
146 | font-feature-settings: "ss01";
147 | }
148 | }
149 | }
150 |
151 |
152 | &:hover, &:focus, &:focus-within {
153 | top: calc(50% - 66px);
154 |
155 | a.ivrita-logo {
156 | height: 0;
157 | visibility: hidden;
158 | }
159 |
160 | a.ivrita-button {
161 | visibility: visible;
162 | font-size: 30px;
163 | height: 33px;
164 | }
165 |
166 | a.ivrita-info-link {
167 | border-top: 1px solid #555;
168 | margin: 4px 0 0;
169 | height: auto;
170 | visibility: visible;
171 | }
172 | }
173 | }
174 |
175 |
176 | /**
177 | * Toolbar
178 | */
179 |
180 | .ivrita-toolbar {
181 | * {
182 | display: inline-block !important;
183 | }
184 |
185 | font-size: 16px;
186 | border: 1px solid rgba(0, 0, 0, 0.15);
187 | display: -webkit-box;
188 | display: -ms-flexbox;
189 | display: flex;
190 | -webkit-box-pack: justify;
191 | -ms-flex-pack: justify;
192 | justify-content: space-between;
193 | margin-bottom: 1.6em !important;
194 | padding: 0.5em 0.7em;
195 | overflow: auto;
196 | position: relative;
197 | align-items: center;
198 | background: rgba(0, 0, 0, 0.03);
199 | color: #333333;
200 | font-size: 18px;
201 | z-index: 1;
202 |
203 | .ivrita-toolbar-label {
204 | padding-left: 0.2em;
205 | opacity: 0.7;
206 | line-height: 1em;
207 | }
208 |
209 | a {
210 | color: #333333 !important;
211 | text-decoration: none !important;
212 | border: none !important;
213 | box-shadow: none !important;
214 | -webkit-box-shadow: none !important;
215 | transition: color .3s !important;
216 | display: inline-block !important;
217 | padding: 0 0.3em !important;
218 | margin: 1px !important;
219 | white-space: nowrap;
220 | cursor: pointer !important;
221 |
222 | &:before {
223 | content: attr(data-ivrita-icon) !important;
224 | font-size: 1.2em !important;
225 | vertical-align: middle !important;
226 | font-family: 'Ivritacons' !important;
227 | }
228 |
229 | &:focus, &:hover {
230 | border: 1px solid rgba(0, 0, 0, 0.2) !important;
231 | margin: 0 !important;
232 | }
233 |
234 | &.ivrita-mode-changer {
235 | border-radius: 2px !important;
236 | }
237 |
238 | &.ivrita-active {
239 | border: 1px solid rgba(0, 0, 0, 0.8) !important;
240 | margin: 0 !important;
241 | }
242 |
243 | &.ivrita-toolbar-info {
244 | padding: 0 !important;
245 | margin: 0 !important;
246 | line-height: 1em;
247 |
248 | &:hover {
249 | border: none !important;
250 |
251 | &:before {
252 | -webkit-font-feature-settings: "ss01";
253 | font-feature-settings: "ss01";
254 | }
255 | }
256 | }
257 | }
258 | }
259 |
260 | /* Mobile CSS */
261 | @media screen and (max-width: 480px) {
262 | .ivrita-switch {
263 | top: auto;
264 | bottom: 0;
265 | border-bottom: 0;
266 | border-bottom-right-radius: 0px !important;
267 | border-bottom-left-radius: 0px !important;
268 |
269 | &:hover {
270 | top: auto;
271 | }
272 | }
273 |
274 | .ivrita-toolbar {
275 | font-size: 14px;
276 |
277 | .ivrita-toolbar-menu {
278 | display: block !important;
279 | width: 100%;
280 | }
281 |
282 | .ivrita-toolbar-label {
283 | display: block !important;
284 | clear: both;
285 | margin-bottom: 0.3em;
286 | }
287 |
288 | a.ivrita-toolbar-info {
289 | position: absolute !important;
290 | left: 0.8em;
291 | top: 0.4em;
292 | }
293 | }
294 | }
--------------------------------------------------------------------------------
/src/wordlists.js:
--------------------------------------------------------------------------------
1 | import {
2 | G, SEP, EXTSEP, B,
3 | } from './utils/characters';
4 |
5 | export const custom = [
6 | [`א${EXTSEP}נשים`, 'אנשים', 'נשים'], // א.נשים
7 | [`א${EXTSEP}נש(?:ות|י)${B}`, 'אנשי', 'נשות'], // א.נשי
8 | [`את${SEP}ה`, 'אתה', 'את'], // את/ה
9 | [`איש${SEP}(?:אש)?ת`, 'איש', 'אשת'], // איש/אשת, איש/ת
10 | [`אשת${SEP}איש`, 'איש', 'אשת'], // אשת/איש
11 | [`(גבר|איש)${SEP}אישה`, '$1', 'אישה'], // גבר/אישה, איש/אישה
12 | [`אחי${SEP}ותי${B}`, 'אחי', 'אחותי'], // אחי/ותי
13 | [`אח${SEP}ות${B}`, 'אח', 'אחות'], // אח/ות
14 | [`ל(ו|ה)${SEP}ל(ו|ה)${B}`, 'לו', 'לה'], // לו/לה, לה/לו
15 | [`ב(ן|ת)${SEP}ב(ן|ת)${B}`, 'בן', 'בת'], // בת/בן, בן/בת
16 | [`ה(ו|י)א${SEP}ה(ו|י)א${B}`, 'הוא', 'היא'], // הוא/היא, היא/הוא
17 | [`אנשי${SEP}ות${B}`, 'אנשי', 'נשות'], // אנשי/ות
18 | [`מישהו${SEP}י${B}`, 'מישהו', 'מישהי'], // מישהו/י
19 | [`אחד${SEP}(אח)?ת${B}`, 'אחד', 'אחת'], // אחד/ת, אחד/אחת
20 | [`אחת${SEP}(אח)?ד${B}`, 'אחד', 'אחת'], // אחת/ד, אחת/אחד
21 | [`יקיר(י?)${SEP}תי${B}`, 'יקירי', 'יקירתי'], // יקירי/תי
22 | [`אהוב(י?)${SEP}תי${B}`, 'אהובי', 'אהובתי'], // אהובי/תי
23 | ['סב\\(ת\\)א', 'סבא', 'סבתא'], // סבא/סבתא
24 | [`זה${SEP}זאת${B}`, 'זה', 'זאת'], // זה/זאת
25 | [`זאת${SEP}זה${B}`, 'זה', 'זאת'], // זאת/זה
26 | [`זה${SEP}ז?ו${B}`, 'זה', 'זו'], // זה/זו
27 | [`זו${SEP}ז?ה${B}`, 'זה', 'זו'], // זו/זה
28 | [`נשוי${SEP}א?ה${B}`, 'נשוי', 'נשואה'], // נשוי/אה
29 | [`חשוב${SEP}י${B}`, 'חשוב', 'חשבי'], // חשוב/י (exception because of שוב/י which is in verbsFemaleKeepVav)
30 | [`חשוב${SEP}י${SEP}ו${B}`, 'חשוב', 'חשבי', 'חשבו'], // חשוב/י/ו (exception because of שוב/י which is in verbsFemaleKeepVav)
31 | ];
32 |
33 | // For most verbs (Unless found in *verbsFemaleKeepVav*), we follow the rules of:
34 | // כתוב/י => Vav before last letter => Vav removed => כתבי
35 | // else:
36 | // לך/י => Yod added after original word => לכי
37 | // However, some verbs need an aditional Yod before their last letter:
38 | // הקשב => Add Yod before and after Bet => הקשיבי
39 | // This is the list of words which need that extra Yod:
40 | export const verbsFemaleExtraYod = [
41 | 'האר',
42 | 'הבא',
43 | 'הגב',
44 | 'הדגם',
45 | 'הדלק',
46 | 'הוסף',
47 | 'הואל',
48 | 'הורד',
49 | 'הזמן',
50 | 'הזן',
51 | 'הכנס',
52 | 'הלבש',
53 | 'המלץ',
54 | 'המשך',
55 | 'הסר',
56 | 'הסתר',
57 | 'הפעל',
58 | 'הפקד',
59 | 'הצג',
60 | 'הקלד',
61 | 'הקלק',
62 | 'הקש',
63 | 'הקשב',
64 | 'הרגש',
65 | 'הרם',
66 | 'הרעף',
67 | 'השב',
68 | 'השלם',
69 | 'השתק',
70 | 'התמד',
71 | 'התקן',
72 | 'העתק',
73 | 'הדבק',
74 | ];
75 |
76 | export const verbsFemaleKeepVav = [
77 | 'קום',
78 | 'רוץ',
79 | 'עופ',
80 | 'שוב',
81 | 'זוז',
82 | 'טוס',
83 | 'שוט',
84 | 'בוא',
85 | ];
86 |
87 | // Most plurals don't need an extra Yod on their female form: מורים->מורות
88 | // These are the exceptions which need a Yod:
89 | export const pluralsWithExtraYod = [
90 | '(א|ס)ובי(י?)קטיב', // אוביקטיבי וסוביקטיבי
91 | `אחמ([${G}]?)ש`,
92 | `ח([${G}])כ`,
93 | `מ([${G}])פ`,
94 | `מנכ([${G}]?)ל`,
95 | `מפא([${G}]?)יניק`,
96 | `משת([${G}]?)פ`,
97 | `עו([${G}])(ס|ד)`,
98 | `רו([${G}])ח`,
99 | `רשג([${G}]?)ד`,
100 | 'א(י?)כפת',
101 | 'אביב',
102 | 'אח',
103 | 'אגרונומ',
104 | 'אדריכל',
105 | 'אוטיסט',
106 | 'אוסטר(ל?)',
107 | 'אופטימ',
108 | 'אחרא',
109 | 'אחיינ',
110 | 'איטלק',
111 | 'אינדיבידואליסט',
112 | 'אירונ',
113 | 'אירופא',
114 | 'אכזר',
115 | 'אלגנט',
116 | 'אלכוהוליסט',
117 | 'אלמונ',
118 | 'אמית',
119 | 'אמריק(א|נ)',
120 | 'אנאלפבית',
121 | 'אנגל',
122 | 'אנוש',
123 | 'אנטישמ',
124 | 'אנליסט',
125 | 'אנרכיסט',
126 | 'אסטרולוג',
127 | 'אסיאת',
128 | 'אפריק(נ|א)',
129 | 'אצנ',
130 | 'אקדמ(א?)',
131 | 'אקטואל',
132 | 'אקטיביסט',
133 | 'אקרא',
134 | 'ארטיסט',
135 | 'אשכנז',
136 | 'אתאיסט',
137 | 'אתיופ',
138 | 'בוגדנ',
139 | 'בולגר',
140 | 'בטחונ',
141 | 'ביביסט',
142 | 'ב(י?)דיונ',
143 | 'בינונ',
144 | 'בינלאומ',
145 | 'בל(א?)גניסט',
146 | 'בלוגר',
147 | 'בלונד',
148 | 'במא',
149 | 'ברב(א?)ר',
150 | 'ברונט',
151 | 'בריט',
152 | 'ברמנ',
153 | `ג${G}ובניק`,
154 | `ג${G}ינג${G}`,
155 | 'גות',
156 | 'גיטריסט',
157 | 'גר(א?)פ',
158 | 'גרמנ',
159 | 'גרפיקא',
160 | 'דברנ',
161 | 'דוקטורנט',
162 | 'דושבג',
163 | 'דיאטנ',
164 | 'דינ(א?)מ',
165 | '(י?)הוד',
166 | 'הי(פ?)סטר',
167 | 'היפ',
168 | 'הססנ',
169 | 'הנדסא',
170 | 'הרמונ',
171 | 'וטרינר',
172 | 'זכא',
173 | 'חבר(ו?)ת',
174 | 'חובבנ',
175 | 'חולמנ',
176 | 'חושנ',
177 | 'חילונ',
178 | 'חי(ו|נ)נ',
179 | 'חיפא',
180 | 'חמדנ',
181 | 'חרד',
182 | 'חרד(ת?)',
183 | 'חרמנ',
184 | 'חשמלא',
185 | 'טבח',
186 | 'טבעונ',
187 | 'טורק',
188 | 'טיפוגרפ',
189 | 'טכנא',
190 | 'טרוריסט',
191 | 'טרמפיסט',
192 | 'טרנס',
193 | 'ידידות',
194 | 'יוגיסט',
195 | 'יוונ',
196 | 'יורקר',
197 | 'יזמ',
198 | 'ימא',
199 | 'ימ(י?)נ',
200 | 'ירושלמ',
201 | 'ישראל',
202 | 'כימא',
203 | 'כלכלנ',
204 | 'כרונ',
205 | 'לבנונ',
206 | 'לוחמנ',
207 | 'ליברל',
208 | 'ליכודניק',
209 | 'מאסטר',
210 | 'מוזיק(ל|א)',
211 | 'מומח',
212 | 'מזוכיסט',
213 | 'מזרח',
214 | 'מחזא',
215 | 'מטאליסט',
216 | 'מטרידנ',
217 | 'מילואימניק',
218 | 'מיליארדר',
219 | 'מיליונר',
220 | 'מכונא',
221 | 'מלאכ',
222 | 'מלצר',
223 | 'מפסידנ',
224 | 'מצליחנ',
225 | 'מצפונ',
226 | 'מקצוע(נ?)',
227 | 'מרדנ',
228 | 'מרקסיסט',
229 | 'נגר',
230 | 'נובוריש',
231 | 'נודיסט',
232 | 'נודניק',
233 | 'נוצר',
234 | 'נורא',
235 | 'נורווג',
236 | 'נטורופת',
237 | 'נרקומנ',
238 | 'ס(א?)דיסט',
239 | 'ס(א?)ח',
240 | 'סדרנ',
241 | 'סהרור',
242 | 'סוליד(ר?)',
243 | 'סוציאליסט',
244 | 'סטודנט',
245 | 'סטרייט',
246 | 'סמכות',
247 | 'סנדלר',
248 | 'סנוב',
249 | 'ססגונ',
250 | 'ספונטנ',
251 | 'ספורטיב',
252 | 'ספציפ',
253 | 'ספרד',
254 | 'סקסולוג',
255 | 'סרב',
256 | 'סרטט',
257 | 'עירונ',
258 | 'עיתונא',
259 | 'עממ',
260 | 'עניינ',
261 | 'ענק',
262 | 'עסיס',
263 | 'עצמא',
264 | 'עקרונ',
265 | 'ערב',
266 | 'ערס',
267 | 'פאנקיסט',
268 | 'פדופיל',
269 | 'פוליטיקא',
270 | 'פולנ',
271 | 'פופול(א?)ר',
272 | 'פופוליסט',
273 | 'פחדנ',
274 | 'פטריוט',
275 | 'פילוסופ',
276 | 'פיזיוטרפיסט',
277 | 'פמיניסט',
278 | 'פסיכופת',
279 | 'פסיכולוג',
280 | 'פסיכיאטר',
281 | 'פסנתרנ',
282 | 'פציפיסט',
283 | 'פריק',
284 | 'פרופסור',
285 | 'פרזנטור',
286 | 'פריל(א?)נסר',
287 | 'פרסומא',
288 | 'פקח',
289 | 'פשיסט',
290 | 'צבע',
291 | 'צבעונ',
292 | 'צי(ו?)נ',
293 | 'ציבור',
294 | 'ציפלונ',
295 | 'צמחונ',
296 | 'צפונ',
297 | 'צרפת',
298 | 'קדמונ',
299 | 'קוויר',
300 | 'קומוניסט',
301 | 'קומיק(ס?)א',
302 | 'קונדיטור',
303 | 'קוסמטיקא',
304 | 'קופא',
305 | 'קוקסינל',
306 | 'קטלנ',
307 | 'קטנונ',
308 | 'קיבוצניק',
309 | 'קיצונ',
310 | 'קלאס',
311 | 'קלדנ',
312 | 'קלפטומנ',
313 | 'קניינ',
314 | 'קפדנ',
315 | 'קפיטליסט',
316 | 'קריקטוריסט',
317 | 'קצב',
318 | 'רבנ',
319 | 'רוחנ',
320 | 'רוס',
321 | 'רוקיסט',
322 | 'רמא',
323 | 'רפד',
324 | 'רקדנ',
325 | 'ש(ו?)ויונ',
326 | 'שאפתנ',
327 | 'שוביניסט',
328 | 'שווד',
329 | 'שוויצר',
330 | 'שחיינ',
331 | 'שחקנ',
332 | 'שלומיאל',
333 | 'שמאלנ',
334 | 'שמנמנ',
335 | 'שמרנ',
336 | 'שפ', //*
337 | 'שק(ר|ד)נ',
338 | 'שרמנט',
339 | 'תורכ',
340 | 'תזונא',
341 | 'תחמנ',
342 | 'תסריטא',
343 | 'תצפיתנ',
344 | 'תקציבא',
345 | 'תרבות',
346 | ];
347 |
--------------------------------------------------------------------------------
/src/element.js:
--------------------------------------------------------------------------------
1 | import {
2 | MALE, FEMALE, NEUTRAL, ORIGINAL, GENDERS, genderize,
3 | } from './ivrita';
4 | import TextAttribute from './textAttribute';
5 | import TextElement, { MALE_DATA_ATTR, FEMALE_DATA_ATTR, NEUTRAL_DATA_ATTR } from './textElement';
6 | import TextNode from './textNode';
7 | import TextObject from './textObject';
8 | import { HEB, SYNTAX } from './utils/characters';
9 |
10 | const hebrewRegex = new RegExp(HEB);
11 | const ivritaSyntaxRegex = new RegExp(SYNTAX);
12 |
13 | const MULTI = GENDERS.length; // ENUM-like
14 |
15 | export default class IvritaElement {
16 | static EVENT_MODE_CHANGED = 'ivrita-mode-changed';
17 |
18 | static ORIGINAL = ORIGINAL;
19 |
20 | static MALE = MALE;
21 |
22 | static FEMALE = FEMALE;
23 |
24 | static NEUTRAL = NEUTRAL;
25 |
26 | // MULTI is a special with FFS enabled, but is essentialy the NEUTRAL mode.
27 | static MULTI = MULTI;
28 |
29 | static GENDERS = [...GENDERS, MULTI];
30 |
31 | static instances = new Map();
32 |
33 | static defaultMode = NEUTRAL;
34 |
35 | static genderize = genderize;
36 |
37 | static textObjects = TextObject.instances;
38 |
39 | nodes = new Set();
40 |
41 | elements = [];
42 |
43 | mode;
44 |
45 | fontFeatureSettings;
46 |
47 | relavantAttributes = {
48 | 'a, img, button, input': ['title'],
49 | [`input:not([type=${['submit', 'button', 'checkbox', 'radio', 'hidden', 'image', 'range', 'reset', 'file'].join(']):not([type=')}])`]: ['placeholder'],
50 | 'input[type=submit], input[type=button], input[type=reset]': ['value'],
51 | };
52 |
53 | constructor(elem, mode) {
54 | if (typeof elem === 'undefined') {
55 | this.elements = [document.body];
56 | const titleTag = document.documentElement.querySelector('title');
57 | if (titleTag) {
58 | this.elements.push(titleTag);
59 | }
60 | } else if (elem instanceof Array && elem.filter((el) => el instanceof HTMLElement)) {
61 | this.elements = elem;
62 | } else if (elem instanceof NodeList) {
63 | this.elements = Array.from(elem);
64 | } else if (elem instanceof HTMLElement) {
65 | this.elements = [elem];
66 | } else if (typeof jQuery === 'function' && elem instanceof jQuery && typeof elem.toArray === 'function') {
67 | this.elements = elem.toArray();
68 | } else {
69 | throw new Error('Passed argument is not an HTMLElement.');
70 | }
71 |
72 | if (this.elements.length === 1 && this.constructor.instances.has(this.elements[0])) {
73 | const preExistingInstance = this.constructor.instances.get(this.elements[0]);
74 | preExistingInstance.registerTextObjects(this.elements[0]); // Make sure nodes are registered
75 | return preExistingInstance;
76 | }
77 |
78 | this.observer = new MutationObserver(this.onElementChange.bind(this));
79 | this.elements.forEach((el) => {
80 | this.observer.observe(el, {
81 | childList: true,
82 | subtree: true,
83 | characterData: false,
84 | });
85 | this.constructor.instances.set(el, this);
86 | this.registerTextObjects(el);
87 | });
88 |
89 | if (typeof mode !== 'undefined') {
90 | this.setMode(mode);
91 | } else if (this.constructor.defaultMode) {
92 | this.setMode(this.constructor.defaultMode);
93 | }
94 | }
95 |
96 | destroy() {
97 | this.setMode(ORIGINAL);
98 | this.setFontFeatureSettings(false);
99 | if (this.observer) {
100 | this.observer.disconnect();
101 | }
102 | this.nodes.clear();
103 | this.elements.forEach((el) => {
104 | this.constructor.instances.delete(el);
105 | });
106 | }
107 |
108 | static setDefaultMode(newMode) {
109 | this.defaultMode = newMode;
110 | }
111 |
112 | setMode(newMode = NEUTRAL) {
113 | if (!this.constructor.GENDERS.includes(newMode)) {
114 | return this;
115 | }
116 |
117 | if ((this.mode === MULTI && newMode !== MULTI) || (this.mode !== MULTI && newMode === MULTI)) {
118 | this.setFontFeatureSettings(newMode === MULTI);
119 | }
120 |
121 | this.mode = newMode;
122 | // If the new mode is MULTI, mask it from the child nodes - for them it's a NEUTRAL mode.
123 | this.nodes.forEach((node) => node.setMode(newMode === MULTI ? NEUTRAL : newMode));
124 |
125 | this.dispatchModeChangedEvent(newMode);
126 |
127 | return this;
128 | }
129 |
130 | static setMode(newMode) {
131 | this.instances.forEach((instance) => instance.setMode(newMode));
132 | }
133 |
134 | genderize(text) {
135 | return this.constructor.genderize(text, this.mode);
136 | }
137 |
138 | dispatchModeChangedEvent(mode = this.mode) {
139 | this.elements.forEach(
140 | (el) => el.dispatchEvent(new CustomEvent(this.constructor.EVENT_MODE_CHANGED,
141 | { bubbles: true, detail: { mode, firingInstance: this } })),
142 | );
143 | }
144 |
145 | registerTextObjects(element) {
146 | this.registerTextNodes(element);
147 | this.registerTextAttributes(element);
148 | }
149 |
150 | registerTextNodes(element) {
151 | let currentNode;
152 | const walk = document.createTreeWalker(
153 | element,
154 | NodeFilter.SHOW_ELEMENT + NodeFilter.SHOW_TEXT,
155 | {
156 | acceptNode: (node) => (this.constructor.acceptNodeFilter(node)),
157 | },
158 | );
159 |
160 | // eslint-disable-next-line no-cond-assign
161 | while ((currentNode = walk.nextNode())) {
162 | let newNode;
163 | if (currentNode instanceof Text) {
164 | newNode = new TextNode(currentNode);
165 | } else if (currentNode instanceof Element) {
166 | newNode = new TextElement(currentNode);
167 | }
168 | this.nodes.add(newNode);
169 | // Set the new node's mode to the current mode, to get in line with everything else
170 | if (this.mode) {
171 | newNode.setMode(this.mode);
172 | }
173 | }
174 | }
175 |
176 | registerTextAttributes(element) {
177 | Object.entries(this.relavantAttributes).forEach(([selector, attributes]) => {
178 | Array.from(element.querySelectorAll(selector)).forEach((input) => {
179 | attributes.forEach((attrName) => {
180 | if (input.hasAttribute(attrName)) {
181 | this.nodes.add(new TextAttribute(input.getAttributeNode(attrName)));
182 | }
183 | });
184 | });
185 | });
186 | }
187 |
188 | static acceptNodeFilter(node) {
189 | if (TextObject.instances.has(node)) { // Already indexed, will be a pointer to existing node
190 | return NodeFilter.FILTER_ACCEPT;
191 | }
192 |
193 | if (node.textContent.trim().length <= 0) {
194 | return NodeFilter.FILTER_REJECT; // If there's no content, reject all child nodes
195 | }
196 |
197 | if (node.nodeType === Node.ELEMENT_NODE) {
198 | if (node.dataset.ivritaDisable) {
199 | return NodeFilter.FILTER_REJECT;
200 | }
201 | if ([MALE_DATA_ATTR, FEMALE_DATA_ATTR, NEUTRAL_DATA_ATTR]
202 | .filter((attr) => node.dataset[attr]).length) {
203 | return NodeFilter.FILTER_ACCEPT;
204 | }
205 | } else if (node.nodeType === Node.TEXT_NODE) {
206 | if (hebrewRegex.test(node.textContent) // Test for Hebrew Letters
207 | && ivritaSyntaxRegex.test(node.textContent)) {
208 | return NodeFilter.FILTER_ACCEPT;
209 | }
210 | }
211 | return NodeFilter.FILTER_SKIP;
212 | }
213 |
214 | onElementChange(mutationsList) {
215 | const closest = (el, s) => {
216 | do {
217 | if (el instanceof Element && Element.prototype.matches.call(el, s)) return el;
218 | // eslint-disable-next-line no-param-reassign
219 | el = el.parentElement || el.parentNode;
220 | } while (el !== null && el.nodeType === 1);
221 | return null;
222 | };
223 |
224 | mutationsList.forEach((mutation) => {
225 | if (mutation.type === 'childList') {
226 | const added = Array.from(mutation.addedNodes);
227 | const removed = Array.from(mutation.removedNodes);
228 | if (added.length === removed.length) { // Probably just changed, not really removed
229 | removed.forEach((oldNode, i) => {
230 | if (oldNode.nodeType === Node.TEXT_NODE) {
231 | const newNode = added[i];
232 | if (TextNode.instances.has(oldNode) && newNode.nodeType === Node.TEXT_NODE) {
233 | const nodeObj = TextNode.instances.get(oldNode);
234 | nodeObj.node = newNode; // This is dangerous, make sure it makes sense
235 | TextNode.instances.set(newNode, nodeObj);
236 | TextNode.instances.delete(oldNode);
237 | }
238 | } // TODO: what about nodes with nested text nodes?
239 | });
240 | } else {
241 | added.forEach((node) => {
242 | if (closest(node, '[data-ivrita-disable]')) {
243 | return;
244 | }
245 | if (node.nodeType === Node.TEXT_NODE
246 | && this.constructor.acceptNodeFilter(node) === NodeFilter.FILTER_ACCEPT) {
247 | const ivritaTextNode = new TextNode(node);
248 | this.nodes.add(ivritaTextNode);
249 | // Set the new node's mode to the current mode, to get in line with everything else
250 | if (this.mode) {
251 | ivritaTextNode.setMode(this.mode);
252 | }
253 | } else if (node.childNodes.length > 0) {
254 | this.registerTextNodes(node);
255 | }
256 | });
257 | }
258 | }
259 | });
260 | }
261 |
262 | setFontFeatureSettings(isActive) {
263 | this.fontFeatureSettings = isActive;
264 | this.elements.forEach((el) => {
265 | const originalFFS = el.style.fontFeatureSettings;
266 | let result = originalFFS.slice().replace('normal', '');
267 |
268 | if (isActive) {
269 | if (!result.includes('titl')) {
270 | if (result) { // Only add a space if property exists
271 | result += ', ';
272 | }
273 | result += '"titl"';
274 | }
275 | } else if (result.includes('titl')) {
276 | result = result.replace(/(, )?"?'?titl"?'?/, '');
277 | }
278 |
279 | if (!result) result = 'normal';
280 |
281 | el.style.fontFeatureSettings = result;
282 | });
283 |
284 | return this;
285 | }
286 | }
287 |
288 | if (typeof jQuery === 'function') {
289 | jQuery.fn.ivrita = function ivritajQueryFn(gender) {
290 | return new IvritaElement(this, gender);
291 | };
292 | }
293 |
--------------------------------------------------------------------------------
/test/dom.test.js:
--------------------------------------------------------------------------------
1 | import Ivrita from '../src/element';
2 | import TextObject from '../src/textObject';
3 |
4 | import {
5 | FEMALE, MALE, NEUTRAL, ORIGINAL,
6 | } from '../src/ivrita';
7 |
8 | function waitEventLoop() {
9 | return new Promise((resolve) => setImmediate(resolve));
10 | }
11 |
12 | const template = `
13 | <div id="content">
14 | <p>[מעצבים|מתכנתות|הייטקיסטים] רבים/ות <u>מרגישים/ות</u> <i>תסכול</i>, כאשר <b>פונים/ות</b> אליהם/ן שלא בשפתם/ן.</p>
15 | </div>
16 | `;
17 |
18 | test('DOM plug-in', () => {
19 | document.body.innerHTML = template;
20 | const paragraph = document.querySelector('#content p');
21 |
22 | const ivrita = new Ivrita();
23 |
24 | // Female
25 | ivrita.setMode(FEMALE);
26 | expect(paragraph.innerHTML).toBe('מתכנתות רבות <u>מרגישות</u> <i>תסכול</i>, כאשר <b>פונות</b> אליהן שלא בשפתן.');
27 |
28 | // Male
29 | ivrita.setMode(MALE);
30 | expect(paragraph.innerHTML).toBe('מעצבים רבים <u>מרגישים</u> <i>תסכול</i>, כאשר <b>פונים</b> אליהם שלא בשפתם.');
31 |
32 | // Neutral
33 | ivrita.setMode(NEUTRAL);
34 | expect(paragraph.innerHTML).toBe('הייטקיסטים רבים/ות <u>מרגישים/ות</u> <i>תסכול</i>, כאשר <b>פונים/ות</b> אליהם/ן שלא בשפתם/ן.');
35 |
36 | // Back to original
37 | ivrita.setMode(ORIGINAL);
38 | expect(paragraph.innerHTML).toBe('[מעצבים|מתכנתות|הייטקיסטים] רבים/ות <u>מרגישים/ות</u> <i>תסכול</i>, כאשר <b>פונים/ות</b> אליהם/ן שלא בשפתם/ן.');
39 |
40 | // Back to male
41 | ivrita.setMode(MALE);
42 | expect(paragraph.innerHTML).toBe('מעצבים רבים <u>מרגישים</u> <i>תסכול</i>, כאשר <b>פונים</b> אליהם שלא בשפתם.');
43 |
44 | // Destroy
45 | ivrita.destroy();
46 | expect(paragraph.innerHTML).toBe('[מעצבים|מתכנתות|הייטקיסטים] רבים/ות <u>מרגישים/ות</u> <i>תסכול</i>, כאשר <b>פונים/ות</b> אליהם/ן שלא בשפתם/ן.');
47 |
48 | expect(ivrita.nodes.size).toEqual(0);
49 | });
50 |
51 | test('Default mode is working', () => {
52 | document.body.innerHTML = template;
53 | const paragraph = document.querySelector('#content p');
54 |
55 | new Ivrita();
56 | expect(paragraph.innerHTML).toBe('הייטקיסטים רבים/ות <u>מרגישים/ות</u> <i>תסכול</i>, כאשר <b>פונים/ות</b> אליהם/ן שלא בשפתם/ן.');
57 | });
58 |
59 | test('Single element passed to constructor', () => {
60 | document.body.innerHTML = template;
61 | const ivrita = new Ivrita(document.querySelector('#content'));
62 | const bold = document.querySelector('#content p b');
63 |
64 | ivrita.setMode(MALE);
65 | expect(bold.innerHTML).toBe('פונים');
66 | });
67 |
68 | test('Multiple elements passed to constructor', () => {
69 | document.body.innerHTML = template;
70 | const ivrita = new Ivrita(document.querySelectorAll('b, u, i'));
71 | const bold = document.querySelector('#content p b');
72 | const underlined = document.querySelector('#content p u');
73 | const italic = document.querySelector('#content p i');
74 |
75 | ivrita.setMode(MALE);
76 | expect(bold.innerHTML).toBe('פונים');
77 | expect(underlined.innerHTML).toBe('מרגישים');
78 | expect(italic.innerHTML).toBe('תסכול');
79 | expect(document.body.querySelector('#content p').textContent).toBe('[מעצבים|מתכנתות|הייטקיסטים] רבים/ות מרגישים תסכול, כאשר פונים אליהם/ן שלא בשפתם/ן.');
80 | });
81 |
82 | test('Array of elements passed to constructor', () => {
83 | document.body.innerHTML = template;
84 | const bold = document.querySelector('#content p b');
85 | const underlined = document.querySelector('#content p u');
86 | const italic = document.querySelector('#content p i');
87 | const ivrita = new Ivrita([bold, underlined, italic]);
88 |
89 | ivrita.setMode(MALE);
90 | expect(bold.innerHTML).toBe('פונים');
91 | expect(underlined.innerHTML).toBe('מרגישים');
92 | expect(italic.innerHTML).toBe('תסכול');
93 | });
94 |
95 | test('<title> tag is changed', () => {
96 | document.documentElement.innerHTML = `
97 | <html>
98 | <head>
99 | <title>צור/י קשר
100 |
101 |
102 | ${template}
103 |
104 |