Creazione di nuovi moduli EPT

Il modulo EPT Text contiene le seguenti cartelle:
/ept_text/config/install — contiene le configurazioni per il tipo di paragrafo EPT Text e le istanze dei campi. Altri moduli EPT possono contenere configurazioni per tipi di paragrafo e storage dei campi.
/ept_text/templates — contiene il template paragraph--ept-text--default.html.twig per il paragrafo.
/ept_text/tests — contiene i test per i moduli EPT, attualmente solo un test di installazione.

E altri file standard dei moduli Drupal: composer.json, ept_text.info.yml, readme.md. Maggiori dettagli sulla creazione di moduli personalizzati Drupal si possono trovare nella documentazione ufficiale:

https://www.drupal.org/docs/develop/creating-modules

Creerò un nuovo modulo EPT Countdown che utilizzerà il seguente plugin JavaScript — FlipDown:

https://github.com/PButcher/flipdown

Tutte le librerie di terze parti devono essere forkate e ospitate su Packagist, ad esempio:

https://packagist.org/packages/levmyshkin/flexslider

da:

https://github.com/levmyshkin/flexslider

In questo modo Composer potrà caricarle come normali librerie da Packagist. Queste librerie di terze parti devono includere il campo "type": "drupal-library" in composer.json, e verranno quindi installate nella cartella /libraries per impostazione predefinita:
https://github.com/levmyshkin/flexslider/blob/master/composer.json

Facciamo il fork del repository FlipDown su GitHub.

In generale, non è consigliato fare fork dei repository invece di usare le sorgenti originali. Tuttavia, credo che ciò renda più semplice utilizzare i moduli EPT senza modificare manualmente il composer.json. Immagina quanto sia difficile per un principiante installare Composer, modificare manualmente composer.json e specificare correttamente un URL di repository esterno. Avere la propria libreria su Packagist semplifica l’installazione. Pertanto, è meglio ospitare tutte le librerie di terze parti su Packagist.

Nella pagina del fork su GitHub puoi rinominare il repository. Il nome dovrebbe essere semplice, senza lettere maiuscole o caratteri speciali. Sono consentiti i trattini (-) e gli underscore (_).

Ora abbiamo un nuovo repository:

https://github.com/levmyshkin/flipdown

Aggiungiamo un file composer.json con type impostato a "drupal-library":

git add composer.json
git commit -m 'Add Composer.json file'
git push origin master

Il file composer.json è disponibile qui:

https://github.com/levmyshkin/flipdown/blob/master/composer.json

Se controlli i tag attuali nel repository, non ce ne saranno:

git tag

Di solito seguo la versione della libreria originale. Se l’ultima versione era 1.4.6, incremento la minor version a 1.4.7. Poiché FlipDown non aveva tag, ho creato la versione 1.0.0:

git tag 1.0.0
git push origin 1.0.0

È necessario un tag perché contiene il composer.json con type impostato a "library".

Perché non copiare semplicemente la libreria JS nel modulo?

Puoi copiare solo librerie con licenza GPL. Le librerie JavaScript usano solitamente la licenza MIT. Tecnicamente è possibile, ma le regole di Drupal.org lo vietano:
https://www.drupal.org/about/licensing

Ora pubblichiamo la libreria FlipDown su Packagist:

https://packagist.org/packages/submit

Se ti sei dimenticato di aggiungere composer.json con "type": "drupal-library" prima della pubblicazione — nessun problema. Aggiungi il file e crea un nuovo tag, Packagist recupererà automaticamente gli aggiornamenti.

Ecco la pagina della libreria su Packagist:

https://packagist.org/packages/levmyshkin/flipdown

Assicurati che nella pagina della libreria il tipo sia indicato come drupal-library.

Ora torniamo ai nostri file Drupal e copiamo la cartella ept_text; chiamerò il nuovo modulo ept_countdown:

È necessario eseguire i seguenti passaggi:

• Eliminare le configurazioni in /config/install — le esporteremo nuove in seguito.
• Sostituire tutte le occorrenze di ept_text con ept_countdown.
• Rinominare i file, sostituendo text con countdown.
• Aggiornare le descrizioni del modulo in ept_countdown.info.yml e README.md.

Eseguirò ogni passaggio separatamente con Git, così potrai seguire le modifiche passo dopo passo:

git clone https://git.drupalcode.org/project/ept_countdown.git

Ora abbiamo un template per il nostro modulo e possiamo inviare le modifiche su Drupal.org.

Andiamo sul sito drupal.org alla pagina di creazione di un progetto:

https://www.drupal.org/node/add

Dobbiamo aggiungere un progetto di tipo Modulo:

https://www.drupal.org/node/add/project-module

Titolo: Extra Paragraph Types (EPT): Countdown
Tipo di progetto: Full project
Nome breve: ept_countdown
Stato di manutenzione: Attivamente mantenuto
Stato di sviluppo: In sviluppo attivo
Categorie del modulo: Content, Content Display
Ecosistema: Extra Paragraph Types (EPT): Core

Nel campo Descrizione, di solito inserisco l’elenco completo dei moduli EPT disponibili (vedi l’esempio in Markdown sopra).

Ora abbiamo una pagina progetto del modulo su Drupal.org:
https://www.drupal.org/project/ept_countdown

Nella scheda Version Control puoi trovare le istruzioni su come aggiungere un repository remoto al tuo progetto Git locale:

https://www.drupal.org/project/ept_countdown/git-instructions

Dopo il commit iniziale, dovresti creare un nuovo branch coerente con la versione principale degli altri moduli EPT — attualmente è 1.4.x.

Ora possiamo iniziare ad aggiungere nuove funzionalità al nostro modulo. Il processo è simile allo sviluppo di un modulo personalizzato: creeremo un tipo di paragrafo, aggiungeremo campi e includeremo risorse CSS/JS.

Installa semplicemente il modulo se lo hai generato con Drush.

Per prima cosa, devi creare un nuovo tipo di paragrafo EPT Countdown:

/admin/structure/paragraphs_type/add

Assicurati che il machine name inizi con ept_. Di solito inizio il nome del paragrafo con EPT — in questo modo il machine name verrà formato automaticamente in modo corretto. Il machine name deve corrispondere al nome del modulo? Sì, è consigliato per coerenza e per evitare conflitti con altri moduli EPT. Questo è importante anche per sovrascrivere i template nei moduli invece che nei temi — vedi la funzione ept_core_theme_registry_alter() nel modulo ept_core.

Ora aggiungi il campo EPT Settings: field_ept_settings — questo campo è richiesto per tutti i moduli EPT:

EPT Settings è un campo condiviso dal modulo EPT Core; fornisce impostazioni per DOM Box, background, spaziatura e larghezza.

Dal momento che dobbiamo effettuare un conto alla rovescia fino a una data, aggiungi un campo data/ora:

Ho aggiunto il prefisso ept_ al machine name, ma non è obbligatorio. Puoi chiamarlo, ad esempio, field_countdown_date. Abbiamo anche i campi predefiniti body e title — questo è sufficiente per il paragrafo countdown.

Per i moduli EPT, solitamente usiamo le tab orizzontali nel form di modifica:

Non è obbligatorio, ma è comodo separare contenuto e impostazioni, soprattutto quando ci sono molte opzioni.

Il gruppo padre dovrebbe essere impostato su Tabs con direzione Horizontal e il parametro Width Breakpoint impostato a 120 (o qualsiasi altro valore ridotto):

Ora che abbiamo il tipo di paragrafo, abilita il modulo EPT Countdown per applicare i template:

/admin/modules

Abilita il paragrafo EPT Countdown per il tipo di contenuto desiderato con un campo paragraphs:

Ecco cosa otteniamo nella pagina:

Ora possiamo collegare una libreria di terze parti. Abbiamo già la libreria levmyshkin/flipdown elencata in composer.json, ma poiché si tratta di un modulo personalizzato, dobbiamo installare la libreria manualmente tramite Composer:

composer require levmyshkin/flipdown

La libreria verrà automaticamente installata nella cartella /libraries:

Ora crea il file ept_countdown.libraries.yml e registra le librerie CSS/JS di FlipDown, oltre a un file JS personalizzato ept_flipdown/js/ept_countdown.js, dove in seguito verrà inizializzato il plugin FlipDown:

ept_countdown.libraries.yml:

ept_countdown:
  css:
    component:
      /libraries/flipdown/dist/flipdown.min.css: { minified: true }
  js:
    /libraries/flipdown/dist/flipdown.min.js: { minified: true }
    js/ept_countdown.js: {}
  dependencies:
    - core/once
    - core/drupalSettings

Per i file nella cartella /libraries, usiamo percorsi assoluti che iniziano con una barra.

js/ept_countdown.js:

(function ($, Drupal) {

  /**
   * EBT Countdown behavior.
   */
  Drupal.behaviors.eptCountDown = {
    attach: function (context, settings) {

    }
  };

})(jQuery, Drupal);

Dobbiamo anche allegare la libreria ept_countdown nei template dei paragrafi. Non dimenticare che abbiamo due template:

{{ attach_library('ept_countdown/ept_countdown') }}

Pulisci la cache e verifica che i file JavaScript vengano caricati nella pagina:

Passeremo la data da PHP a JavaScript tramite drupalSettings. Per questo abbiamo esteso il file ept_countdown.libraries.yml aggiungendo le seguenti dipendenze:

  dependencies:
    - core/once
    - core/drupalSettings

Nei moduli EPT, le impostazioni predefinite non vengono passate a JavaScript. Per abilitarlo, dobbiamo sovrascrivere la classe del widget di campo EptSettingsDefaultWidget:

File: ept_countdown/src/Plugin/Field/FieldWidget/EptSettingsCountDownWidget.php

<?php

namespace Drupal\ept_countdown\Plugin\Field\FieldWidget;

use Drupal\Core\Field\FieldItemListInterface;
use Drupal\Core\Form\FormStateInterface;
use Drupal\ept_core\Plugin\Field\FieldWidget\EptSettingsDefaultWidget;

/**
 * Implementazione del plugin per il widget 'ept_settings_countdown'.
 *
 * @FieldWidget(
 *   id = "ept_settings_countdown",
 *   label = @Translation("Impostazioni EPT Countdown"),
 *   field_types = {
 *     "ept_settings"
 *   }
 * )
 */
class EptSettingsCountDownWidget extends EptSettingsDefaultWidget {

  public function formElement(FieldItemListInterface $items, $delta, array $element, array &$form, FormStateInterface $form_state) {
    $element = parent::formElement($items, $delta, $element, $form, $form_state);

    $element['ept_settings']['pass_options_to_javascript'] = [
      '#type' => 'hidden',
      '#value' => TRUE,
    ];

    $element['ept_settings']['color_theme'] = [
      '#title' => $this->t('Tema colore'),
      '#type' => 'radios',
      '#options' => [
        'dark' => $this->t('Scuro'),
        'light' => $this->t('Chiaro'),
      ],
      '#default_value' => $items[$delta]->ept_settings['color_theme'] ?? 'dark',
      '#description' => $this->t('Seleziona il tema colore per il countdown'),
      '#weight' => '3',
    ];

    $element['ept_settings']['styles'] = [
      '#title' => $this->t('Stili'),
      '#type' => 'radios',
      '#options' => [
        'default' => $this->t('Predefinito'),
        'new_year' => $this->t('Capodanno'),
      ],
      '#default_value' => $items[$delta]->ept_settings['styles'] ?? 'default',
      '#description' => $this->t('Seleziona uno stile speciale per il countdown'),
      '#weight' => '4',
    ];

    $element['ept_settings']['heading_days'] = [
      '#title' => $this->t('Intestazione Giorni'),
      '#type' => 'textfield',
      '#default_value' => $items[$delta]->ept_settings['heading_days'] ?? $this->t('Giorni'),
      '#description' => $this->t('Intestazione per il contatore dei Giorni'),
      '#weight' => '5',
    ];

    $element['ept_settings']['heading_hours'] = [
      '#title' => $this->t('Intestazione Ore'),
      '#type' => 'textfield',
      '#default_value' => $items[$delta]->ept_settings['heading_hours'] ?? $this->t('Ore'),
      '#description' => $this->t('Intestazione per il contatore delle Ore'),
      '#weight' => '6',
    ];

    $element['ept_settings']['heading_minutes'] = [
      '#title' => $this->t('Intestazione Minuti'),
      '#type' => 'textfield',
      '#default_value' => $items[$delta]->ept_settings['heading_minutes'] ?? $this->t('Minuti'),
      '#description' => $this->t('Intestazione per il contatore dei Minuti'),
      '#weight' => '7',
    ];

    $element['ept_settings']['heading_seconds'] = [
      '#title' => $this->t('Intestazione Secondi'),
      '#type' => 'textfield',
      '#default_value' => $items[$delta]->ept_settings['heading_seconds'] ?? $this->t('Secondi'),
      '#description' => $this->t('Intestazione per il contatore dei Secondi'),
      '#weight' => '8',
    ];

    return $element;
  }

  public function massageFormValues(array $values, array $form, FormStateInterface $form_state) {
    foreach ($values as &$value) {
      $value += ['ept_settings' => []];
    }
    return $values;
  }
}

Ora possiamo selezionare il nostro widget per il campo EPT Settings:

Percorso: /admin/structure/paragraphs_type/ept_countdown/form-display

Salva il paragrafo e controlla le variabili JavaScript tramite drupalSettings. Ora tutti i parametri da EPT Settings vengono passati allo script:

Alla fine della chiave paragraph-id-* si trova l’ID univoco del paragrafo, che aiuta a identificare il paragrafo corrispondente.

Il plugin FlipDown ha un parametro di tema (chiaro/scuro). Lo passiamo utilizzando il campo color_theme nel widget EptSettingsCountDownWidget:

$element['ept_settings']['color_theme'] = [
  '#title' => $this->t('Tema colore'),
  '#type' => 'radios',
  '#options' => [
    'dark' => $this->t('Scuro'),
    'light' => $this->t('Chiaro'),
  ],
  '#default_value' => $items[$delta]->ept_settings['color_theme'] ?? 'dark',
  '#description' => $this->t('Seleziona il tema colore per il countdown'),
  '#weight' => '3',
];

Ora il valore del tema può essere recuperato in JavaScript tramite drupalSettings e utilizzato per applicare lo stile appropriato:

Abbiamo già passato le impostazioni del paragrafo a JavaScript tramite drupalSettings. Ora dobbiamo anche passare il valore della data dal campo Date. Per farlo, crea un <div> vuoto nel template con un attributo data-date che memorizza il valore del timestamp. Usa paragraph.id() per assegnare un ID univoco al paragrafo:

File: paragraph--ept-countdown--default.html.twig

  <div
    class="ept-countdown-date ept-countdown-inline-block flipdown"
    id="paragraph-id-{{ paragraph.id() }}"
    data-date="{{ content.field_ept_countdown_date[0]['#attributes']['datetime']|date('U') }}">
  </div>

Se non sei sicuro di dove venga memorizzato il valore della data, utilizza il modulo Twig Debugger e inserisci {{ dump(content.field_ept_countdown_date) }} nel template.

Il filtro date('U') converte la data nel formato timestamp Unix.

Ora includi il JavaScript personalizzato e inizializza il plugin FlipDown:

File: /ept_countdown/js/ept_countdown.js

(function ($, Drupal) {

  /**
   * Comportamento EPT Countdown.
   */
  Drupal.behaviors.eptCountDown = {
    attach: function (context, settings) {
      var countdowns = once('ept-countdown-paragraph', '.ept-countdown-date', context);
      countdowns.forEach(function(countdown) {
        var eptOptions = drupalSettings['eptCountdown'][countdown.getAttribute('id')];
        var countdownTimestamp = parseInt(countdown.getAttribute('data-date'));
        var countdownId = countdown.getAttribute('id');

        new FlipDown(countdownTimestamp, countdownId, {
          theme: eptOptions['options']['color_theme'],
        }).start();
      });
    }
  };

})(jQuery, Drupal);

Non dimenticare di svuotare la cache per applicare le modifiche. Dopo di ciò, il plugin FlipDown dovrebbe essere renderizzato correttamente sulla pagina:

Come possiamo vedere, anche gli stili predefiniti di FlipDown non vengono renderizzati perfettamente — ad esempio, su desktop i numeri appaiono su due righe. Ma possiamo facilmente risolvere questo problema con stili personalizzati. Basta copiare i file gulpfile.js e package.json dal modulo EPT Counter o dal modulo EPT Core Kickstarter.

gulpfile.js:

// Carica i plugin
var gulp = require('gulp'),
    sass = require('gulp-dart-scss'),
    postcss = require("gulp-postcss"),
    autoprefixer = require("autoprefixer"),
    cssnano = require("cssnano"),
    notify = require('gulp-notify'),
    sassUnicode = require('gulp-sass-unicode');

var config = {
  scssSrc: 'scss/*.scss',
  allScss: 'scss/**/*.scss',
  cssDest: 'css/',
  allJs: 'assets/js/**/*.js',
  allImgs: 'assets/img/**/*'
};

function style() {
  return gulp.src(config.allScss)
    .pipe(sass())
    .pipe(sassUnicode())
    .pipe(postcss([autoprefixer()]))
    .pipe(gulp.dest(config.cssDest));
}

exports.style = style;

function watch(){
  gulp.watch('scss/**/*.scss', style)
}

exports.watch = watch;

package.json:

{
  "name": "ept_styles",
  "version": "1.0.0",
  "description": "Esegui npm install e poi gulp watch",
  "main": "gulpfile.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "devDependencies": {
    "autoprefixer": "^10.2.5",
    "cssnano": "^5.0.2",
    "gulp": "^4.0.2",
    "gulp-dart-scss": "^1.1.0",
    "gulp-notify": "^4.0.0",
    "gulp-postcss": "^9.0.0",
    "gulp-sass-unicode": "^1.0.5",
    "gulp-sourcemaps": "^3.0.0"
  },
  "dependencies": {
    "cucumber": "*",
    "postcss": "^8.2.13"
  }
}

Il file package-lock.json verrà generato automaticamente dopo aver eseguito:

npm install

Poi puoi avviare il task Gulp con:

gulp watch

Ora, aggiungi un file SCSS:

/ept_countdown/scss/flipdown.scss

.flipdown {
  width: 580px;
}

Il file flipdown.css verrà compilato automaticamente da flipdown.scss. Includilo in ept_countdown.libraries.yml:

ept_countdown:
  css:
    component:
      /libraries/flipdown/dist/flipdown.min.css: { minified: true }
      css/flipdown.css: {}

Svuota la cache e controlla il risultato:

La visualizzazione è ora notevolmente migliorata!

Posso usare CSS normale invece della compilazione SCSS?

Sì, puoi. Ma la maggior parte degli sviluppatori preferisce scrivere in SCSS perché è più comodo e scalabile.

Il plugin FlipDown supporta i parametri theme e headings, che possiamo usare per la personalizzazione della visualizzazione. Abbiamo già creato un widget di campo personalizzato EptSettingsCountDownWidget e ora aggiungeremo i campi corrispondenti.

File: /ept_countdown/src/Plugin/Field/FieldWidget/EptSettingsCountDownWidget.php

public function formElement(FieldItemListInterface $items, $delta, array $element, array &$form, FormStateInterface $form_state) {
  $element = parent::formElement($items, $delta, $element, $form, $form_state);

  $element['ept_settings']['pass_options_to_javascript'] = [
    '#type' => 'hidden',
    '#value' => TRUE,
  ];

  $element['ept_settings']['color_theme'] = [
    '#title' => $this->t('Color theme'),
    '#type' => 'radios',
    '#options' => ['dark' => $this->t('Dark'), 'light' => $this->t('Light')],
    '#default_value' => $items[$delta]->ept_settings['color_theme'] ?? 'dark',
    '#description' => $this->t('Select color theme for countdown'),
    '#weight' => '3',
  ];

  $element['ept_settings']['styles'] = [
    '#title' => $this->t('Styles'),
    '#type' => 'radios',
    '#options' => ['default' => $this->t('Default'), 'new_year' => $this->t('New Year')],
    '#default_value' => $items[$delta]->ept_settings['styles'] ?? 'default',
    '#description' => $this->t('Select special style for countdown'),
    '#weight' => '4',
  ];

  $element['ept_settings']['heading_days'] = [
    '#title' => $this->t('Heading Days'),
    '#type' => 'textfield',
    '#default_value' => $items[$delta]->ept_settings['heading_days'] ?? $this->t('Days'),
    '#description' => $this->t('Header for Days counter'),
    '#weight' => '5',
  ];

  $element['ept_settings']['heading_hours'] = [
    '#title' => $this->t('Heading Hours'),
    '#type' => 'textfield',
    '#default_value' => $items[$delta]->ept_settings['heading_hours'] ?? $this->t('Hours'),
    '#description' => $this->t('Header for Hours counter'),
    '#weight' => '6',
  ];

  $element['ept_settings']['heading_minutes'] = [
    '#title' => $this->t('Heading Minutes'),
    '#type' => 'textfield',
    '#default_value' => $items[$delta]->ept_settings['heading_minutes'] ?? $this->t('Minutes'),
    '#description' => $this->t('Header for Minutes counter'),
    '#weight' => '7',
  ];

  $element['ept_settings']['heading_seconds'] = [
    '#title' => $this->t('Heading Seconds'),
    '#type' => 'textfield',
    '#default_value' => $items[$delta]->ept_settings['heading_seconds'] ?? $this->t('Seconds'),
    '#description' => $this->t('Header for Seconds counter'),
    '#weight' => '8',
  ];

  return $element;
}

Ora possiamo usare le intestazioni e il tema nel template. L’ID dell’elemento segue il pattern paragraph-id-{{ paragraph.id() }}, che ci permette di recuperare i dati da drupalSettings:

new FlipDown(countdownTimestamp, countdownId, {
  theme: eptOptions['options']['color_theme'],
  headings: [
    eptOptions['options']['heading_days'],
    eptOptions['options']['heading_hours'],
    eptOptions['options']['heading_minutes'],
    eptOptions['options']['heading_seconds'],
  ],
}).start();

Inoltre, utilizziamo il valore styles dalle impostazioni per assegnare dinamicamente gli stili nel template:

{%
  set classes = [
    'paragraph',
    'ept-paragraph',
    'ept-paragraph-countdown',
    'paragraph--type--' ~ paragraph.bundle|clean_class,
    'ept-paragraph--type--' ~ paragraph.bundle|clean_class,
    view_mode ? 'paragraph--view-mode--' ~ view_mode|clean_class,
    not paragraph.isPublished() ? 'paragraph--unpublished',
    'paragraph-id-' ~ paragraph.id(),
    content.field_ept_settings['#object'].field_ept_settings.ept_settings.styles,
    content.field_ept_settings['#object'].field_ept_settings.ept_settings.color_theme,
  ]
%}

Allega in modo condizionale gli stili new_year se è selezionato lo stile corrispondente:

{% if content.field_ept_settings['#object'].field_ept_settings.ept_settings.styles == 'new_year' %}
  {{ attach_library('ept_countdown/new_year') }}
{% endif %}

ept_countdown.libraries.yml:

new_year:
  css:
    component:
      css/new-year.css: {}

/ept_countdown/scss/new-year.scss:

.ept-paragraph-countdown.new_year {
  background: url(../img/snowflakes.webp) center center repeat;
}

Risultato:

Puoi aggiungere qualsiasi numero di stili personalizzati per i moduli EPT nuovi o esistenti. Puoi anche suggerire i tuoi stili creando una issue su Drupal.org:

https://www.drupal.org/project/issues/ept_core

Abbiamo completato l’aggiunta di funzionalità a EPT Countdown. Ora è il momento di esportare le configurazioni e preparare il modulo per la pubblicazione su Drupal.org.

Tutte le configurazioni relative al paragrafo EPT Countdown devono essere copiate nella cartella /ept_countdown/config/install.

Se il modulo è stato generato utilizzando Drush, dovresti riesportare le configurazioni per assicurarti che tutte le impostazioni dei campi e del tipo di paragrafo siano aggiornate.

Dopo di ciò, puoi abilitare il modulo dalla pagina Extend — /admin/modules. Tutte le configurazioni di paragrafi e campi per EPT Countdown saranno installate automaticamente da /config/install:

Non è necessario includere i file di configurazione language.*, poiché il modulo Language potrebbe essere disabilitato su alcuni siti.

Di solito copio tutti i file YAML richiesti e mi assicuro che siano posizionati sotto config/install:

Prima del commit, assicurati di rimuovere uuid e hashes dai file YAML:

Se il tuo modulo dipende da altri moduli di Drupal (ad esempio datetime), assicurati di elencarli come dipendenze nel file .info.yml:

/ept_countdown/ept_countdown.info.yml:

dependencies:
  - drupal:datetime

Il tuo modulo è ora pronto per il caricamento e la pubblicazione su Drupal.org.

Abbiamo già creato un nuovo progetto su Drupal.org:

https://www.drupal.org/project/ept_countdown

Il branch principale selezionato è 1.4.x, per mantenere la coerenza con gli altri moduli dell’ecosistema EPT:

Tutte le release inizieranno ora dalla versione 1.4.0:

git tag 1.4.0
git push origin 1.4.0

Puoi anche creare versioni pre-release come -alpha o -beta prima di pubblicare la release stabile 1.4.0.

Devi attendere 10 giorni dopo la creazione del progetto prima che il modulo possa essere incluso nel programma di Security Advisory Coverage:

Ora puoi testare il nuovo modulo su diversi tipi di contenuto, verificare il comportamento di FlipDown, le impostazioni del tema e le intestazioni. Se necessario, segnala bug e rilascia patch.

Se hai generato il modulo EPT utilizzando Drush, il file README.md dovrebbe già essere stato creato automaticamente.

In ogni caso, non dimenticare di includere un file README.md nel tuo modulo. Questo è un file importante che contiene la descrizione del modulo, i requisiti, i passaggi per l’installazione e le linee guida per l’utilizzo. Puoi vedere un esempio in un altro modulo EPT:

https://www.drupal.org/project/ept_slideshow

Grazie per aver utilizzato i moduli EPT! Puoi sempre fare domande o condividere idee:

• Crea una issue su Drupal.org
• Contatta lo sviluppatore del modulo EPT
• Invia un messaggio su LinkedIn