WordPress.org
Get WordPress

Plugin Directory

Changeset 3409391


Ignore:
Timestamp:
12/03/2025 11:35:03 AM (4 months ago)
Author:
cbravobernal
Message:

Add files for 6.7.0 release.

Location:
secure-custom-fields/trunk
Files:
4 added
1 deleted
6 edited

Legend:

Unmodified
Added
Removed

  • secure-custom-fields/trunk/includes/abilities/class-scf-post-type-abilities.php

    r3398367 r3409391  
    2525     * @since 6.6.0
    2626     */
    27     class SCF_Post_Type_Abilities {
     27    class SCF_Post_Type_Abilities extends SCF_Internal_Post_Type_Abilities {
    2828
    2929        /**
    30          * Post type schema to reuse across ability registrations.
     30         * The internal post type identifier.
    3131         *
    32          * @var object|null
     32         * @var string
    3333         */
    34         private $post_type_schema = null;
    35 
    36         /**
    37          * SCF identifier schema to reuse across ability registrations.
    38          *
    39          * @var object|null
    40          */
    41         private $scf_identifier_schema = null;
    42 
    43         /**
    44          * Constructor.
    45          *
    46          * @since 6.6.0
    47          */
    48         public function __construct() {
    49             $validator = acf_get_instance( 'SCF_JSON_Schema_Validator' );
    50 
    51             // Only register abilities if schemas are available
    52             if ( ! $validator->validate_required_schemas() ) {
    53                 return;
    54             }
    55 
    56             add_action( 'wp_abilities_api_categories_init', array( $this, 'register_categories' ) );
    57             add_action( 'wp_abilities_api_init', array( $this, 'register_abilities' ) );
    58         }
    59 
    60         /**
    61          * Get the SCF post type schema, loading it once and caching for reuse.
    62          *
    63          * @since 6.6.0
    64          * @return array The post type schema definition.
    65          */
    66         private function get_post_type_schema() {
    67             if ( null === $this->post_type_schema ) {
    68                 $validator = new SCF_JSON_Schema_Validator();
    69                 $schema    = $validator->load_schema( 'post-type' );
    70 
    71                 $this->post_type_schema = json_decode( wp_json_encode( $schema->definitions->postType ), true );
    72             }
    73 
    74             return $this->post_type_schema;
    75         }
    76 
    77         /**
    78          * Get the SCF identifier schema, loading it once and caching for reuse.
    79          *
    80          * @since 6.6.0
    81          *
    82          * @return array The SCF identifier schema definition.
    83          */
    84         private function get_scf_identifier_schema() {
    85             if ( null === $this->scf_identifier_schema ) {
    86                 $validator = new SCF_JSON_Schema_Validator();
    87 
    88                 $this->scf_identifier_schema = json_decode( wp_json_encode( $validator->load_schema( 'scf-identifier' ) ), true );
    89             }
    90 
    91             return $this->scf_identifier_schema;
    92         }
    93 
    94         /**
    95          * Get the internal fields schema (ID, _valid, local).
    96          *
    97          * @since 6.6.0
    98          * @return array The internal fields schema.
    99          */
    100         private function get_internal_fields_schema() {
    101             $validator = new SCF_JSON_Schema_Validator();
    102             $schema    = $validator->load_schema( 'internal-fields' );
    103 
    104             return json_decode( wp_json_encode( $schema->definitions->internalFields ), true );
    105         }
    106 
    107         /**
    108          * Get the post type schema extended with internal fields for GET/LIST/CREATE/UPDATE/IMPORT/DUPLICATE operations.
    109          *
    110          * @since 6.6.0
    111          *
    112          * @return array The extended post type schema with internal fields.
    113          */
    114         private function get_post_type_with_internal_fields_schema() {
    115             $schema               = $this->get_post_type_schema();
    116             $internal_fields      = $this->get_internal_fields_schema();
    117             $schema['properties'] = array_merge( $schema['properties'], $internal_fields['properties'] );
    118 
    119             return $schema;
    120         }
    121 
    122         /**
    123          * Register SCF ability categories.
    124          *
    125          * @since 6.6.0
    126          */
    127         public function register_categories() {
    128             wp_register_ability_category(
    129                 'scf-post-types',
    130                 array(
    131                     'label'       => __( 'SCF Post Types', 'secure-custom-fields' ),
    132                     'description' => __( 'Abilities for managing Secure Custom Fields post types.', 'secure-custom-fields' ),
    133                 )
    134             );
    135         }
    136 
    137         /**
    138          * Register all post type abilities.
    139          *
    140          * @since 6.6.0
    141          */
    142         public function register_abilities() {
    143             $this->register_list_post_types_ability();
    144             $this->register_get_post_type_ability();
    145             $this->register_create_post_type_ability();
    146             $this->register_update_post_type_ability();
    147             $this->register_delete_post_type_ability();
    148             $this->register_duplicate_post_type_ability();
    149             $this->register_export_post_type_ability();
    150             $this->register_import_post_type_ability();
    151         }
    152 
    153         /**
    154          * Register the list post types ability.
    155          *
    156          * @since 6.6.0
    157          */
    158         private function register_list_post_types_ability() {
    159             wp_register_ability(
    160                 'scf/list-post-types',
    161                 array(
    162                     'label'               => __( 'List Post Types', 'secure-custom-fields' ),
    163                     'description'         => __( 'Retrieves a list of all SCF post types with optional filtering.', 'secure-custom-fields' ),
    164                     'category'            => 'scf-post-types',
    165                     'execute_callback'    => array( $this, 'list_post_types_callback' ),
    166                     'meta'                => array(
    167                         'show_in_rest' => true,
    168                         'mcp'          => array(
    169                             'public' => true,
    170                         ),
    171                         'annotations'  => array(
    172                             'readonly'    => false,
    173                             'destructive' => false,
    174                             'idempotent'  => true,
    175                         ),
    176                     ),
    177                     'permission_callback' => 'scf_current_user_has_capability',
    178                     'input_schema'        => array(
    179                         'type'       => 'object',
    180                         'properties' => array(
    181                             'filter' => array(
    182                                 'type'        => 'object',
    183                                 'description' => __( 'Optional filters to apply to the post type list.', 'secure-custom-fields' ),
    184                                 'properties'  => array(
    185                                     'active' => array(
    186                                         'type'        => 'boolean',
    187                                         'description' => __( 'Filter by active status.', 'secure-custom-fields' ),
    188                                     ),
    189                                     'search' => array(
    190                                         'type'        => 'string',
    191                                         'description' => __( 'Search term to filter post types.', 'secure-custom-fields' ),
    192                                     ),
    193                                 ),
    194                             ),
    195                         ),
    196                     ),
    197                     'output_schema'       => array(
    198                         'type'  => 'array',
    199                         'items' => $this->get_post_type_with_internal_fields_schema(),
    200                     ),
    201                 )
    202             );
    203         }
    204 
    205         /**
    206          * Register the get post type ability.
    207          *
    208          * @since 6.6.0
    209          */
    210         private function register_get_post_type_ability() {
    211             wp_register_ability(
    212                 'scf/get-post-type',
    213                 array(
    214                     'label'               => __( 'Get Post Type', 'secure-custom-fields' ),
    215                     'description'         => __( 'Retrieves a specific SCF post type configuration by ID or key.', 'secure-custom-fields' ),
    216                     'category'            => 'scf-post-types',
    217                     'execute_callback'    => array( $this, 'get_post_type_callback' ),
    218                     'meta'                => array(
    219                         'show_in_rest' => true,
    220                         'mcp'          => array(
    221                             'public' => true,
    222                         ),
    223                         'annotations'  => array(
    224                             'readonly'    => false,
    225                             'destructive' => false,
    226                             'idempotent'  => true,
    227                         ),
    228                     ),
    229                     'permission_callback' => 'scf_current_user_has_capability',
    230                     'input_schema'        => array(
    231                         'type'       => 'object',
    232                         'properties' => array(
    233                             'identifier' => $this->get_scf_identifier_schema(),
    234                         ),
    235                         'required'   => array( 'identifier' ),
    236                     ),
    237                     'output_schema'       => $this->get_post_type_with_internal_fields_schema(),
    238                 )
    239             );
    240         }
    241 
    242         /**
    243          * Register the create post type ability.
    244          *
    245          * @since 6.6.0
    246          */
    247         private function register_create_post_type_ability() {
    248             $input_schema = $this->get_post_type_schema();
    249 
    250             wp_register_ability(
    251                 'scf/create-post-type',
    252                 array(
    253                     'label'               => __( 'Create Post Type', 'secure-custom-fields' ),
    254                     'description'         => __( 'Creates a new custom post type in SCF with the provided configuration.', 'secure-custom-fields' ),
    255                     'category'            => 'scf-post-types',
    256                     'execute_callback'    => array( $this, 'create_post_type_callback' ),
    257                     'meta'                => array(
    258                         'show_in_rest' => true,
    259                         'mcp'          => array(
    260                             'public' => true,
    261                         ),
    262                         'annotations'  => array(
    263                             'readonly'    => false,
    264                             'destructive' => false,
    265                             'idempotent'  => false,
    266                         ),
    267                     ),
    268                     'permission_callback' => 'scf_current_user_has_capability',
    269                     'input_schema'        => $input_schema,
    270                     'output_schema'       => $this->get_post_type_with_internal_fields_schema(),
    271                 )
    272             );
    273         }
    274 
    275         /**
    276          * Register the update post type ability.
    277          *
    278          * @since 6.6.0
    279          */
    280         private function register_update_post_type_ability() {
    281 
    282             // For updates, only ID is required, everything else is optional
    283             $input_schema             = $this->get_post_type_with_internal_fields_schema();
    284             $input_schema['required'] = array( 'ID' );
    285 
    286             wp_register_ability(
    287                 'scf/update-post-type',
    288                 array(
    289                     'label'               => __( 'Update Post Type', 'secure-custom-fields' ),
    290                     'description'         => __( 'Updates an existing SCF post type with new configuration.', 'secure-custom-fields' ),
    291                     'category'            => 'scf-post-types',
    292                     'execute_callback'    => array( $this, 'update_post_type_callback' ),
    293                     'meta'                => array(
    294                         'show_in_rest' => true,
    295                         'mcp'          => array(
    296                             'public' => true,
    297                         ),
    298                         'annotations'  => array(
    299                             'readonly'    => false,
    300                             'destructive' => false,
    301                             'idempotent'  => true,
    302                         ),
    303                     ),
    304                     'permission_callback' => 'scf_current_user_has_capability',
    305                     'input_schema'        => $input_schema,
    306                     'output_schema'       => $this->get_post_type_with_internal_fields_schema(),
    307                 )
    308             );
    309         }
    310 
    311         /**
    312          * Register the delete post type ability.
    313          *
    314          * @since 6.6.0
    315          */
    316         private function register_delete_post_type_ability() {
    317             wp_register_ability(
    318                 'scf/delete-post-type',
    319                 array(
    320                     'label'               => __( 'Delete Post Type', 'secure-custom-fields' ),
    321                     'description'         => __( 'Permanently deletes an SCF post type. This action cannot be undone.', 'secure-custom-fields' ),
    322                     'category'            => 'scf-post-types',
    323                     'execute_callback'    => array( $this, 'delete_post_type_callback' ),
    324                     'meta'                => array(
    325                         'show_in_rest' => true,
    326                         'mcp'          => array(
    327                             'public' => true,
    328                         ),
    329                         'annotations'  => array(
    330                             'readonly'    => false,
    331                             'destructive' => true,
    332                             'idempotent'  => true,
    333                         ),
    334                     ),
    335                     'permission_callback' => 'scf_current_user_has_capability',
    336                     'input_schema'        => array(
    337                         'type'       => 'object',
    338                         'properties' => array(
    339                             'identifier' => $this->get_scf_identifier_schema(),
    340                         ),
    341                         'required'   => array( 'identifier' ),
    342                     ),
    343                     'output_schema'       => array(
    344                         'type'        => 'boolean',
    345                         'description' => __( 'True if post type was successfully deleted.', 'secure-custom-fields' ),
    346                     ),
    347                 )
    348             );
    349         }
    350 
    351         /**
    352          * Register the duplicate post type ability.
    353          *
    354          * @since 6.6.0
    355          */
    356         private function register_duplicate_post_type_ability() {
    357             wp_register_ability(
    358                 'scf/duplicate-post-type',
    359                 array(
    360                     'label'               => __( 'Duplicate Post Type', 'secure-custom-fields' ),
    361                     'description'         => __( 'Creates a copy of an existing SCF post type with optional modifications.', 'secure-custom-fields' ),
    362                     'category'            => 'scf-post-types',
    363                     'execute_callback'    => array( $this, 'duplicate_post_type_callback' ),
    364                     'meta'                => array(
    365                         'show_in_rest' => true,
    366                         'mcp'          => array(
    367                             'public' => true,
    368                         ),
    369                         'annotations'  => array(
    370                             'readonly'    => false,
    371                             'destructive' => false,
    372                             'idempotent'  => false,
    373                         ),
    374                     ),
    375                     'permission_callback' => 'scf_current_user_has_capability',
    376                     'input_schema'        => array(
    377                         'type'       => 'object',
    378                         'properties' => array(
    379                             'identifier'  => $this->get_scf_identifier_schema(),
    380                             'new_post_id' => array(
    381                                 'type'        => 'integer',
    382                                 'description' => __( 'Optional new post ID for the duplicated post type.', 'secure-custom-fields' ),
    383                             ),
    384                         ),
    385                         'required'   => array( 'identifier' ),
    386                     ),
    387                     'output_schema'       => $this->get_post_type_with_internal_fields_schema(),
    388                 )
    389             );
    390         }
    391 
    392         /**
    393          * Register the export post type ability.
    394          *
    395          * @since 6.6.0
    396          */
    397         private function register_export_post_type_ability() {
    398             wp_register_ability(
    399                 'scf/export-post-type',
    400                 array(
    401                     'label'               => __( 'Export Post Type', 'secure-custom-fields' ),
    402                     'description'         => __( 'Exports an SCF post type configuration as JSON for backup or transfer.', 'secure-custom-fields' ),
    403                     'category'            => 'scf-post-types',
    404                     'execute_callback'    => array( $this, 'export_post_type_callback' ),
    405                     'meta'                => array(
    406                         'show_in_rest' => true,
    407                         'mcp'          => array(
    408                             'public' => true,
    409                         ),
    410                         'annotations'  => array(
    411                             'readonly'    => true,
    412                             'destructive' => false,
    413                             'idempotent'  => true,
    414                         ),
    415                     ),
    416                     'permission_callback' => 'scf_current_user_has_capability',
    417                     'input_schema'        => array(
    418                         'type'       => 'object',
    419                         'properties' => array(
    420                             'identifier' => $this->get_scf_identifier_schema(),
    421                         ),
    422                         'required'   => array( 'identifier' ),
    423                     ),
    424                     'output_schema'       => $this->get_post_type_schema(),
    425                 )
    426             );
    427         }
    428 
    429         /**
    430          * Register the import post type ability.
    431          *
    432          * @since 6.6.0
    433          */
    434         private function register_import_post_type_ability() {
    435             wp_register_ability(
    436                 'scf/import-post-type',
    437                 array(
    438                     'label'               => __( 'Import Post Type', 'secure-custom-fields' ),
    439                     'description'         => __( 'Imports an SCF post type from JSON configuration data.', 'secure-custom-fields' ),
    440                     'category'            => 'scf-post-types',
    441                     'execute_callback'    => array( $this, 'import_post_type_callback' ),
    442                     'meta'                => array(
    443                         'show_in_rest' => true,
    444                         'mcp'          => array(
    445                             'public' => true,
    446                         ),
    447                         'annotations'  => array(
    448                             'readonly'    => false,
    449                             'destructive' => false,
    450                             'idempotent'  => false,
    451                         ),
    452                     ),
    453                     'permission_callback' => 'scf_current_user_has_capability',
    454                     'input_schema'        => $this->get_post_type_with_internal_fields_schema(),
    455                     'output_schema'       => $this->get_post_type_with_internal_fields_schema(),
    456                 )
    457             );
    458         }
    459 
    460         /**
    461          * Callback for the list post types ability.
    462          *
    463          * @since 6.6.0
    464          *
    465          * @param array $input The input parameters.
    466          * @return array The response data.
    467          */
    468         public function list_post_types_callback( $input ) {
    469             $filter = isset( $input['filter'] ) ? $input['filter'] : array();
    470 
    471             $post_types = acf_get_acf_post_types( $filter );
    472             return is_array( $post_types ) ? $post_types : array();
    473         }
    474 
    475         /**
    476          * Callback for the get post type ability.
    477          *
    478          * @since 6.6.0
    479          *
    480          * @param array $input The input parameters.
    481          * @return array The response data.
    482          */
    483         public function get_post_type_callback( $input ) {
    484             $post_type = acf_get_post_type( $input['identifier'] );
    485 
    486             if ( ! $post_type ) {
    487                 return new WP_Error( 'post_type_not_found', __( 'Post type not found.', 'secure-custom-fields' ) );
    488             }
    489 
    490             return $post_type;
    491         }
    492 
    493         /**
    494          * Callback for the create post type ability.
    495          *
    496          * @since 6.6.0
    497          *
    498          * @param array $input The input parameters.
    499          * @return array The response data.
    500          */
    501         public function create_post_type_callback( $input ) {
    502             // Check if post type already exists.
    503             if ( acf_get_post_type( $input['key'] ) ) {
    504                 return new WP_Error( 'post_type_exists', __( 'A post type with this key already exists.', 'secure-custom-fields' ) );
    505             }
    506 
    507             $post_type = acf_update_post_type( $input );
    508 
    509             if ( ! $post_type ) {
    510                 return new WP_Error( 'create_post_type_failed', __( 'Failed to create post type.', 'secure-custom-fields' ) );
    511             }
    512 
    513             return $post_type;
    514         }
    515 
    516         /**
    517          * Callback for the update post type ability.
    518          *
    519          * @since 6.6.0
    520          *
    521          * @param array $input The input parameters.
    522          * @return array|WP_Error The post type data on success, WP_Error on failure.
    523          */
    524         public function update_post_type_callback( $input ) {
    525             $existing_post_type = acf_get_post_type( $input['ID'] );
    526             if ( ! $existing_post_type ) {
    527                 return new WP_Error( 'post_type_not_found', __( 'Post type not found.', 'secure-custom-fields' ) );
    528             }
    529 
    530             // Merge input with existing post type data to preserve unmodified fields.
    531             $input = array_merge( $existing_post_type, $input );
    532 
    533             $post_type = acf_update_post_type( $input );
    534 
    535             if ( ! $post_type ) {
    536                 return new WP_Error( 'update_post_type_failed', __( 'Failed to update post type.', 'secure-custom-fields' ) );
    537             }
    538 
    539             return $post_type;
    540         }
    541 
    542         /**
    543          * Callback for the delete post type ability.
    544          *
    545          * @since 6.6.0
    546          *
    547          * @param array $input The input parameters.
    548          * @return bool|WP_Error True on success, WP_Error on failure.
    549          */
    550         public function delete_post_type_callback( $input ) {
    551             $result = acf_delete_post_type( $input['identifier'] );
    552 
    553             if ( ! $result ) {
    554                 return new WP_Error( 'delete_post_type_failed', __( 'Failed to delete post type.', 'secure-custom-fields' ) );
    555             }
    556 
    557             return true;
    558         }
    559 
    560         /**
    561          * Callback for the duplicate post type ability.
    562          *
    563          * @since 6.6.0
    564          *
    565          * @param array $input The input parameters.
    566          * @return array|WP_Error The duplicated post type data on success, WP_Error on failure.
    567          */
    568         public function duplicate_post_type_callback( $input ) {
    569             $new_post_id          = isset( $input['new_post_id'] ) ? $input['new_post_id'] : 0;
    570             $duplicated_post_type = acf_duplicate_post_type( $input['identifier'], $new_post_id );
    571 
    572             if ( ! $duplicated_post_type ) {
    573                 return new WP_Error( 'duplicate_post_type_failed', __( 'Failed to duplicate post type.', 'secure-custom-fields' ) );
    574             }
    575 
    576             return $duplicated_post_type;
    577         }
    578 
    579         /**
    580          * Callback for the export post type ability.
    581          *
    582          * @since 6.6.0
    583          *
    584          * @param array $input The input parameters.
    585          * @return array|WP_Error The export data on success, WP_Error on failure.
    586          */
    587         public function export_post_type_callback( $input ) {
    588             $post_type = acf_get_post_type( $input['identifier'] );
    589             if ( ! $post_type ) {
    590                 return new WP_Error( 'post_type_not_found', __( 'Post type not found.', 'secure-custom-fields' ) );
    591             }
    592 
    593             $export_data = acf_prepare_internal_post_type_for_export( $post_type, 'acf-post-type' );
    594 
    595             if ( ! $export_data ) {
    596                 return new WP_Error( 'export_post_type_failed', __( 'Failed to prepare post type for export.', 'secure-custom-fields' ) );
    597             }
    598 
    599             return $export_data;
    600         }
    601 
    602         /**
    603          * Callback for the import post type ability.
    604          *
    605          * @since 6.6.0
    606          *
    607          * @param array|object $input The input parameters.
    608          * @return array|WP_Error The imported post type data on success, WP_Error on failure.
    609          */
    610         public function import_post_type_callback( $input ) {
    611             // Import the post type (handles both create and update based on presence of ID).
    612             $imported_post_type = acf_import_internal_post_type( $input, 'acf-post-type' );
    613 
    614             if ( ! $imported_post_type ) {
    615                 return new WP_Error( 'import_post_type_failed', __( 'Failed to import post type.', 'secure-custom-fields' ) );
    616             }
    617 
    618             return $imported_post_type;
    619         }
     34        protected $internal_post_type = 'acf-post-type';
    62035    }
    62136
    … …  
    62338    acf_new_instance( 'SCF_Post_Type_Abilities' );
    62439
    625 
    626 endif; // class_exists check
     40endif; // class_exists check.

  • secure-custom-fields/trunk/includes/class-scf-json-schema-validator.php

    r3398367 r3409391  
    2323
    2424        /**
    25          * Required schema files for post type abilities
     25         * Required schema files for SCF abilities.
    2626         *
    2727         * @var array
    2828         */
    29         public const REQUIRED_SCHEMAS = array( 'post-type', 'internal-fields', 'scf-identifier' );
     29        public const REQUIRED_SCHEMAS = array( 'post-type', 'taxonomy', 'internal-fields', 'scf-identifier' );
    3030
    3131        /**

  • secure-custom-fields/trunk/readme.txt

    r3408248 r3409391  
    5252
    5353== Changelog ==
     54
     55= 6.7.0 =
     56*Release Date 2 Dec 2025*
     57
     58*Features*
     59
     60- Tested compatibility up to WordPress 6.9.
     61- Abilities support. Taxonomy abilities.
     62- JSON schemas. Taxonomy schema.
     63
    5464
    5565= 6.6.0 =

  • secure-custom-fields/trunk/schemas/post-type.schema.json

    r3398154 r3409391  
    1919        "postType": {
    2020            "type": "object",
    21             "required": ["key", "title", "post_type"],
     21            "required": [ "key", "title", "post_type" ],
    2222            "additionalProperties": false,
    2323            "properties": {
    … …  
    5151                },
    5252                "advanced_configuration": {
    53                     "type": "boolean",
     53                    "type": [ "boolean", "integer" ],
    5454                    "default": false,
    55                     "description": "[SCF Export Only] Whether advanced configuration options are enabled"
     55                    "description": "[SCF Export Only] Whether advanced configuration options are enabled. Accepts boolean or integer (0/1)."
    5656                },
    5757                "import_source": {
    … …  
    250250                },
    251251                "menu_position": {
    252                     "type": ["integer", "string", "null"],
     252                    "type": [ "integer", "string", "null" ],
    253253                    "description": "The position in the menu order. SCF exports as empty string or null when not set, integer when set. Import accepts all types and casts to integer."
    254254                },
    … …  
    264264                                "type": {
    265265                                    "type": "string",
    266                                     "enum": ["dashicons", "url"],
     266                                    "enum": [ "dashicons", "url" ],
    267267                                    "description": "Icon source type: 'dashicons' for WordPress dashicons, 'url' for custom image"
    268268                                },
    … …  
    272272                                }
    273273                            },
    274                             "required": ["type", "value"],
     274                            "required": [ "type", "value" ],
    275275                            "additionalProperties": false,
    276276                            "description": "[SCF] SCF icon object format: {\"type\": \"dashicons\", \"value\": \"dashicons-admin-post\"}"
    … …  
    317317                },
    318318                "delete_with_user": {
    319                     "type": ["boolean", "null"],
     319                    "type": [ "boolean", "null" ],
    320320                    "description": "Whether to delete posts of this type when deleting a user"
    321321                },
    322322
    323323                "has_archive": {
    324                     "type": ["boolean", "string"],
     324                    "type": [ "boolean", "string" ],
    325325                    "default": false,
    326326                    "description": "Whether there should be post type archives, or if a string, the archive slug to use"
    … …  
    331331                },
    332332                "rewrite": {
    333                     "type": ["object", "boolean"],
     333                    "type": [ "object", "boolean" ],
    334334                    "description": "Triggers the handling of rewrites for this post type",
    335335                    "oneOf": [
    … …  
    348348                                },
    349349                                "with_front": {
    350                                     "type": ["boolean", "string"],
     350                                    "type": [ "boolean", "string" ],
    351351                                    "default": true,
    352352                                    "description": "Whether the permalink structure should be prepended with WP_Rewrite::$front (accepts boolean or string '0'/'1' for backward compatibility)"
    353353                                },
    354354                                "feeds": {
    355                                     "type": ["boolean", "string"],
     355                                    "type": [ "boolean", "string" ],
    356356                                    "default": false,
    357357                                    "description": "Whether the feed permalink structure should be built for this post type (accepts boolean or string '0'/'1' for backward compatibility)"
    358358                                },
    359359                                "pages": {
    360                                     "type": ["boolean", "string"],
     360                                    "type": [ "boolean", "string" ],
    361361                                    "default": true,
    362362                                    "description": "Whether the permalink structure should provide for pagination (accepts boolean or string '0'/'1' for backward compatibility)"
    … …  
    367367                },
    368368                "query_var": {
    369                     "type": ["boolean", "string"],
     369                    "type": [ "boolean", "string" ],
    370370                    "description": "Sets the query_var key for this post type"
    371371                },
    … …  
    376376
    377377                "capability_type": {
    378                     "type": ["string", "array"],
     378                    "type": [ "string", "array" ],
    379379                    "description": "The string to use to build the read, edit, and delete capabilities"
    380380                },
    … …  
    502502            "singular_capability_name": "post",
    503503            "plural_capability_name": "posts",
    504             "supports": ["title", "editor", "thumbnail", "custom-fields"],
     504            "supports": [ "title", "editor", "thumbnail", "custom-fields" ],
    505505            "taxonomies": "",
    506506            "has_archive": false,

  • secure-custom-fields/trunk/secure-custom-fields.php

    r3395245 r3409391  
    77 * Plugin URI:        https://developer.wordpress.org/secure-custom-fields/
    88 * Description:       Secure Custom Fields (SCF) offers an intuitive way for developers to enhance WordPress content management by adding extra fields and options without coding requirements.
    9  * Version:           6.6.0
     9 * Version:           6.7.0
    1010 * Author:            WordPress.org
    1111 * Author URI:        https://wordpress.org/
    … …  
    3434         * @var string
    3535         */
    36         public $version = '6.6.0';
     36        public $version = '6.7.0';
    3737
    3838        /**
    … …  
    191191            acf_include( 'includes/class-acf-site-health.php' );
    192192            acf_include( 'includes/class-scf-json-schema-validator.php' );
    193             acf_include( 'includes/abilities/abilities-integration.php' );
     193            acf_include( 'includes/abilities/class-scf-abilities-integration.php' );
    194194            acf_include( 'includes/fields/class-acf-field.php' );
    195195            acf_include( 'includes/locations/abstract-acf-legacy-location.php' );

  • secure-custom-fields/trunk/vendor/composer/installed.php

    r3398367 r3409391  
    44        'pretty_version' => 'dev-trunk',
    55        'version' => 'dev-trunk',
    6         'reference' => 'a71c0b102b4a93af0b8763d07ca8e150b1ccacce',
     6        'reference' => 'a0381930bb8fc339ff506743ef7ceda10e75ad06',
    77        'type' => 'wordpress-plugin',
    88        'install_path' => __DIR__ . '/../../',
    … …  
    2323            'pretty_version' => 'dev-trunk',
    2424            'version' => 'dev-trunk',
    25             'reference' => 'a71c0b102b4a93af0b8763d07ca8e150b1ccacce',
     25            'reference' => 'a0381930bb8fc339ff506743ef7ceda10e75ad06',
    2626            'type' => 'wordpress-plugin',
    2727            'install_path' => __DIR__ . '/../../',
Note: See TracChangeset for help on using the changeset viewer.